@jsenv/core 23.0.9 → 23.1.4

package/src/internal/compiling/createCompiledFileService.js

@@ -1,4 +1,4 @@
-import { serveFile } from "@jsenv/server"
+import { serveFile, nextService } from "@jsenv/server"
 import {
   resolveUrl,
   resolveDirectoryUrl,
@@ -31,7 +31,6 @@ const jsenvCompilers = {
 }
 
 export const createCompiledFileService = ({
-  sourceFileService,
   cancellationToken,
   logger,
 
@@ -51,6 +50,7 @@ export const createCompiledFileService = ({
   projectFileRequestedCallback,
   useFilesystemAsCache,
   compileCacheStrategy,
+  sourcemapMethod,
   sourcemapExcludeSources,
 }) => {
   Object.keys(customCompilers).forEach((key) => {
@@ -80,7 +80,7 @@ export const createCompiledFileService = ({
 
     // not inside compile directory -> nothing to compile
     if (!requestCompileInfo.insideCompileDirectory) {
-      return sourceFileService(request)
+      return null
     }
 
     const { compileId, afterCompileId } = requestCompileInfo
@@ -110,7 +110,7 @@ export const createCompiledFileService = ({
 
     // nothing after compileId, we don't know what to compile (not supposed to happen)
     if (afterCompileId === "") {
-      return sourceFileService(request)
+      return null
     }
 
     const originalFileRelativeUrl = afterCompileId
@@ -132,7 +132,7 @@ export const createCompiledFileService = ({
     // we don't redirect otherwise it complexify ressource tracking
     // and url resolution
     if (!compiler) {
-      return sourceFileService({
+      return nextService({
         ...request,
         ressource: `/${originalFileRelativeUrl}`,
       })
@@ -175,7 +175,7 @@ export const createCompiledFileService = ({
             groupMap,
           }),
 
-          sourcemapMethod: "comment", // "inline" is also possible
+          sourcemapMethod,
           sourcemapExcludeSources,
           jsenvToolbarInjection,
         })

package/src/internal/compiling/jsenvCompilerForHtml.js

@@ -6,7 +6,10 @@ import {
   jsenvToolbarInjectorFileInfo,
 } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
 import { getDefaultImportMap } from "@jsenv/core/src/internal/import-resolution/importmap-default.js"
-import { setJavaScriptSourceMappingUrl } from "../sourceMappingURLUtils.js"
+import {
+  setJavaScriptSourceMappingUrl,
+  sourcemapToBase64Url,
+} from "../sourceMappingURLUtils.js"
 import { transformJs } from "./js-compilation-service/transformJs.js"
 import {
   parseHtmlString,
@@ -41,6 +44,7 @@ export const compileHtml = async ({
   babelPluginMap,
 
   jsenvToolbarInjection,
+  sourcemapMethod,
 }) => {
   const jsenvBrowserBuildUrlRelativeToProject = urlToRelativeUrl(
     jsenvBrowserSystemFileInfo.jsenvBuildUrl,
@@ -203,12 +207,22 @@ export const compileHtml = async ({
         sourcemapFileUrl,
         compiledUrl,
       )
-      code = setJavaScriptSourceMappingUrl(
-        code,
-        sourcemapFileRelativePathForModule,
-      )
-      assets = [...assets, scriptAssetUrl, sourcemapFileUrl]
-      assetsContent = [...assetsContent, code, JSON.stringify(map, null, "  ")]
+
+      if (sourcemapMethod === "inline") {
+        code = setJavaScriptSourceMappingUrl(code, sourcemapToBase64Url(map))
+      } else {
+        // TODO: respect "sourcemapMethod" parameter
+        code = setJavaScriptSourceMappingUrl(
+          code,
+          sourcemapFileRelativePathForModule,
+        )
+        assets = [...assets, scriptAssetUrl, sourcemapFileUrl]
+        assetsContent = [
+          ...assetsContent,
+          code,
+          JSON.stringify(map, null, "  "),
+        ]
+      }
     }),
   )
 

package/src/internal/compiling/jsenvCompilerForJavaScript.js

@@ -14,6 +14,7 @@ export const compileJavascript = async ({
   importMetaFormat,
 
   sourcemapExcludeSources,
+  sourcemapMethod,
 }) => {
   const transformResult = await transformJs({
     code,
@@ -42,6 +43,7 @@ export const compileJavascript = async ({
       compiledFileUrl: compiledUrl,
       sourcemapFileUrl: `${compiledUrl}.map`,
       sourcemapExcludeSources,
+      sourcemapMethod,
     },
   )
 }

package/src/internal/compiling/startCompileServer.js

@@ -59,6 +59,7 @@ export const startCompileServer = async ({
   jsenvDirectoryClean = false,
   outDirectoryName = "out",
 
+  sourcemapMethod = "comment", // "inline" is also possible
   sourcemapExcludeSources = false, // this should increase perf (no need to download source for browser)
   compileServerCanReadFromFilesystem = true,
   compileServerCanWriteOnFilesystem = true,
@@ -269,6 +270,8 @@ export const startCompileServer = async ({
     babelPluginMap,
     customCompilers,
     jsenvToolbarInjection,
+    sourcemapMethod,
+    sourcemapExcludeSources,
   })
   if (compileServerCanWriteOnFilesystem) {
     await setupOutDirectory({
@@ -280,31 +283,6 @@ export const startCompileServer = async ({
     })
   }
 
-  const sourceFileService = composeServicesWithTiming({
-    ...(transformHtmlSourceFiles
-      ? {
-          "service:transform html source file":
-            createTransformHtmlSourceFileService({
-              logger,
-              projectDirectoryUrl,
-              inlineImportMapIntoHTML,
-              jsenvScriptInjection,
-              jsenvToolbarInjection,
-            }),
-        }
-      : {}),
-    "service:source file": createSourceFileService({
-      logger,
-      projectDirectoryUrl,
-      projectFileRequestedCallback,
-      projectFileEtagEnabled,
-      transformHtmlSourceFiles,
-      inlineImportMapIntoHTML,
-      jsenvScriptInjection,
-      jsenvToolbarInjection,
-    }),
-  })
-
   const jsenvServices = {
     "service:compilation asset": createCompilationAssetFileService({
       projectDirectoryUrl,
@@ -324,7 +302,6 @@ export const startCompileServer = async ({
       projectDirectoryUrl,
     }),
     "service:compiled file": createCompiledFileService({
-      sourceFileService,
       cancellationToken,
       logger,
 
@@ -345,9 +322,32 @@ export const startCompileServer = async ({
       projectFileRequestedCallback,
       useFilesystemAsCache: compileServerCanReadFromFilesystem,
       writeOnFilesystem: compileServerCanWriteOnFilesystem,
+      sourcemapMethod,
       sourcemapExcludeSources,
       compileCacheStrategy,
     }),
+    ...(transformHtmlSourceFiles
+      ? {
+          "service:transform html source file":
+            createTransformHtmlSourceFileService({
+              logger,
+              projectDirectoryUrl,
+              inlineImportMapIntoHTML,
+              jsenvScriptInjection,
+              jsenvToolbarInjection,
+            }),
+        }
+      : {}),
+    "service:source file": createSourceFileService({
+      logger,
+      projectDirectoryUrl,
+      projectFileRequestedCallback,
+      projectFileEtagEnabled,
+      transformHtmlSourceFiles,
+      inlineImportMapIntoHTML,
+      jsenvScriptInjection,
+      jsenvToolbarInjection,
+    }),
   }
 
   const compileServer = await startServer({
@@ -361,7 +361,8 @@ export const startCompileServer = async ({
     ip: compileServerIp,
     port: compileServerPort,
     sendServerTiming: true,
-    nagle: false,
+    // nagle: false,
+    requestWaitingMs: 60 * 1000,
     sendServerInternalErrorDetails: true,
     requestToResponse: composeServicesWithTiming({
       ...customServices,
@@ -945,6 +946,8 @@ const createOutJSONFiles = ({
   inlineImportMapIntoHTML,
   customCompilers,
   jsenvToolbarInjection,
+  sourcemapMethod,
+  sourcemapExcludeSources,
 }) => {
   const outJSONFiles = {}
   const outDirectoryUrl = resolveUrl(
@@ -968,6 +971,8 @@ const createOutJSONFiles = ({
     processEnvNodeEnv,
     customCompilerPatterns,
     jsenvToolbarInjection,
+    sourcemapMethod,
+    sourcemapExcludeSources,
   }
   outJSONFiles.meta = {
     url: metaOutFileUrl,

package/src/internal/executing/coverage/v8CoverageFromNodeV8Directory.js

@@ -4,6 +4,7 @@ import {
   readFile,
   resolveUrl,
 } from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
 
 import { v8CoverageFromAllV8Coverages } from "./v8CoverageFromAllV8Coverages.js"
 
@@ -12,7 +13,9 @@ export const v8CoverageFromNodeV8Directory = async ({
   NODE_V8_COVERAGE,
   coverageConfig,
 }) => {
-  const allV8Coverages = await readV8CoverageReportsFromDirectory(NODE_V8_COVERAGE)
+  const allV8Coverages = await readV8CoverageReportsFromDirectory(
+    NODE_V8_COVERAGE,
+  )
 
   const v8Coverage = v8CoverageFromAllV8Coverages(allV8Coverages, {
     coverageRootUrl: projectDirectoryUrl,
@@ -28,33 +31,47 @@ const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
     if (dirContent.length > 0) {
       return dirContent
     }
-    if (timeSpentTrying > 1500) {
-      console.warn(`v8 coverage directory is empty at ${coverageDirectory}`)
-      return dirContent
+    if (timeSpentTrying < 800) {
+      await new Promise((resolve) => setTimeout(resolve, 100))
+      return tryReadDirectory(timeSpentTrying + 100)
     }
-    await new Promise((resolve) => setTimeout(resolve, 100))
-    return tryReadDirectory(timeSpentTrying + 100)
+    console.warn(`v8 coverage directory is empty at ${coverageDirectory}`)
+    return dirContent
   }
   const dirContent = await tryReadDirectory()
 
   const coverageReports = []
-
   const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(coverageDirectory)
   await Promise.all(
     dirContent.map(async (dirEntry) => {
       const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      try {
-        const fileContent = await readFile(dirEntryUrl, { as: "json" })
-        if (fileContent) {
-          coverageReports.push(fileContent)
+      const tryReadJsonFile = async (timeSpentTrying = 0) => {
+        try {
+          const fileContent = await readFile(dirEntryUrl, { as: "json" })
+          return fileContent
+        } catch (e) {
+          if (e.name === "SyntaxError") {
+            // If there is a syntax error it's likely because Node.js
+            // is not done writing the json file content
+            // -> let's retry to read file after 100ms
+            if (timeSpentTrying < 100) {
+              await new Promise((resolve) => setTimeout(resolve, 100))
+              return tryReadJsonFile(timeSpentTrying + 100)
+            }
+          }
+          console.warn(
+            createDetailedMessage(`Error while reading coverage file`, {
+              "error stack": e.stack,
+              "file": dirEntryUrl,
+            }),
+          )
+          return null
         }
-      } catch (e) {
-        console.warn(`Error while reading coverage file
---- error stack ---
-${e.stack}
---- file ---
-${dirEntryUrl}`)
-        return
+      }
+
+      const fileContent = await tryReadJsonFile()
+      if (fileContent) {
+        coverageReports.push(fileContent)
       }
     }),
   )

package/src/internal/executing/executionLogs.js

@@ -54,7 +54,7 @@ file: ${fileRelativeUrl}
 runtime: ${runtime}${appendDuration({
     startMs,
     endMs,
-  })}${appendConsole(consoleCalls)}${appendError(error)}`
+  })}${appendConsole(consoleCalls)}${appendError(error, runtimeName)}`
 }
 
 const descriptionFormatters = {
@@ -107,8 +107,17 @@ ${consoleOutputTrimmed}
 ${setANSIColor(`-------------------------`, ANSI_GREY)}`
 }
 
-const appendError = (error) => {
-  if (!error) return ``
+const appendError = (error, runtimeName) => {
+  if (!error) {
+    return ``
+  }
+
+  if (runtimeName === "webkit") {
+    return `
+error: ${error.message}
+  at ${error.stack}`
+  }
+
   return `
 error: ${error.stack}`
 }

package/src/internal/executing/launchAndExecute.js

@@ -47,7 +47,10 @@ export const launchAndExecute = async ({
   runtimeConsoleCallback = () => {},
   runtimeStartedCallback = () => {},
   runtimeStoppedCallback = () => {},
-  runtimeErrorCallback = () => {},
+  runtimeErrorAfterExecutionCallback = (error) => {
+    // by default throw on error after execution
+    throw error
+  },
   runtimeDisconnectCallback = () => {},
 
   coverageV8MergeConflictIsExpected,
@@ -205,7 +208,7 @@ export const launchAndExecute = async ({
     stopAfterExecuteReason,
     gracefulStopAllocatedMs,
     runtimeConsoleCallback,
-    runtimeErrorCallback,
+    runtimeErrorAfterExecutionCallback,
     runtimeDisconnectCallback,
     runtimeStartedCallback,
     runtimeStoppedCallback,
@@ -280,7 +283,7 @@ const computeExecutionResult = async ({
   runtimeStartedCallback,
   runtimeStoppedCallback,
   runtimeConsoleCallback,
-  runtimeErrorCallback,
+  runtimeErrorAfterExecutionCallback,
   runtimeDisconnectCallback,
 }) => {
   const runtimeLabel = `${runtime.name}/${runtime.version}`
@@ -387,17 +390,6 @@ const computeExecutionResult = async ({
 
       timing = TIMING_DURING_EXECUTION
 
-      registerErrorCallback((error) => {
-        logger.error(
-          createDetailedMessage(`error ${timing}.`, {
-            ["error stack"]: error.stack,
-            ["execute params"]: JSON.stringify(executeParams, null, "  "),
-            ["runtime"]: runtimeLabel,
-          }),
-        )
-        runtimeErrorCallback({ error, timing })
-      })
-
       const raceResult = await promiseTrackRace([disconnected, executed])
       timing = TIMING_AFTER_EXECUTION
 
@@ -406,7 +398,24 @@ const computeExecutionResult = async ({
       }
 
       if (stopAfterExecute) {
-        launchOperation.stop(stopAfterExecuteReason)
+        // if there is an error while stopping the runtine
+        // the execution is considered as failed
+        try {
+          await launchOperation.stop(stopAfterExecuteReason)
+        } catch (e) {
+          return finalizeExecutionResult(
+            createErroredExecutionResult({
+              error: e,
+            }),
+          )
+        }
+      } else {
+        // when the process is still alive
+        // we want to catch error to notify runtimeErrorAfterExecutionCallback
+        // and throw that error by default
+        registerErrorCallback((error) => {
+          runtimeErrorAfterExecutionCallback(error)
+        })
       }
 
       const executionResult = raceResult.value

package/src/internal/logs/log_style.js

@@ -3,6 +3,18 @@ import { createSupportsColor } from "supports-color"
 
 const canUseUnicode = isUnicodeSupported()
 const processSupportsBasicColor = createSupportsColor(process.stdout).hasBasic
+let canUseColors = processSupportsBasicColor
+
+// GitHub workflow does support ANSI but "supports-color" returns false
+// because stream.isTTY returns false, see https://github.com/actions/runner/issues/241
+if (process.env.GITHUB_WORKFLOW) {
+  // Check on FORCE_COLOR is to ensure it is prio over GitHub workflow check
+  if (process.env.FORCE_COLOR !== "false") {
+    // in unit test we use process.env.FORCE_COLOR = 'false' to fake
+    // that colors are not supported. Let it have priority
+    canUseColors = true
+  }
+}
 
 const ansiStyles = {
   red: { open: 31, close: 39 },
@@ -22,7 +34,7 @@ export const ANSI_GREY = ansiStyles.grey
 
 export const ANSI_RESET = "\x1b[0m"
 
-export const setANSIColor = processSupportsBasicColor
+export const setANSIColor = canUseColors
   ? (text, ansiColor) =>
       `\x1b[${ansiColor.open}m${text}\x1b[${ansiColor.close}m`
   : (text) => text

package/src/internal/node-launcher/createControllableNodeProcess.js

@@ -77,16 +77,17 @@ export const createControllableNodeProcess = async ({
   }
 
   await assertFilePresence(nodeControllableFileUrl)
+  const envForChildProcess = {
+    ...(inheritProcessEnv ? process.env : {}),
+    ...env,
+  }
   const childProcess = forkChildProcess(
     urlToFileSystemPath(nodeControllableFileUrl),
     {
       execArgv,
       // silent: true
       stdio: ["pipe", "pipe", "pipe", "ipc"],
-      env: {
-        ...(inheritProcessEnv ? process.env : {}),
-        ...env,
-      },
+      env: envForChildProcess,
     },
   )
 
@@ -123,14 +124,17 @@ ${JSON.stringify(env, null, "  ")}`)
   const registerConsoleCallback = (callback) => {
     consoleCallbackArray.push(callback)
   }
-  installProcessOutputListener(childProcess, ({ type, text }) => {
-    consoleCallbackArray.forEach((callback) => {
-      callback({
-        type,
-        text,
+  const removeOutputListener = installProcessOutputListener(
+    childProcess,
+    ({ type, text }) => {
+      consoleCallbackArray.forEach((callback) => {
+        callback({
+          type,
+          text,
+        })
       })
-    })
-  })
+    },
+  )
   // keep listening process outputs while child process is killed to catch
   // outputs until it's actually disconnected
   // registerCleanupCallback(removeProcessOutputListener)
@@ -138,38 +142,68 @@ ${JSON.stringify(env, null, "  ")}`)
   const errorCallbackArray = []
   const registerErrorCallback = (callback) => {
     errorCallbackArray.push(callback)
+    return () => {
+      const index = errorCallbackArray.indexOf(callback)
+      if (index > -1) {
+        errorCallbackArray.splice(index, 1)
+      }
+    }
   }
   let killing = false
-  installProcessErrorListener(childProcess, (error) => {
-    if (!childProcess.connected && error.code === "ERR_IPC_DISCONNECTED") {
-      return
-    }
-    // on windows killProcessTree uses taskkill which seems to kill the process
-    // with an exitCode of 1
-    if (process.platform === "win32" && killing && error.exitCode === 1) {
-      return
-    }
-    errorCallbackArray.forEach((callback) => {
-      callback(error)
-    })
-  })
+  const removeErrorListener = installProcessErrorListener(
+    childProcess,
+    (error) => {
+      removeOutputListener()
+      if (!childProcess.connected && error.code === "ERR_IPC_DISCONNECTED") {
+        return
+      }
+      // on windows killProcessTree uses taskkill which seems to kill the process
+      // with an exitCode of 1
+      if (process.platform === "win32" && killing && error.exitCode === 1) {
+        return
+      }
+      errorCallbackArray.forEach((callback) => {
+        callback(error)
+      })
+    },
+  )
   // keep listening process errors while child process is killed to catch
   // errors until it's actually disconnected
   // registerCleanupCallback(removeProcessErrorListener)
 
   // https://nodejs.org/api/child_process.html#child_process_event_disconnect
   let resolveDisconnect
+  let hasExitedOrDisconnected = false
   const disconnected = new Promise((resolve) => {
-    resolveDisconnect = resolve
-    onceProcessMessage(childProcess, "disconnect", () => {
-      resolve()
-    })
-    onceProcessEvent(childProcess, "disconnect", () => {
+    resolveDisconnect = () => {
+      hasExitedOrDisconnected = true
+      removeExitListener()
+      removeDisconnectListener()
+    }
+
+    const removeDisconnectListener = onceProcessEvent(
+      childProcess,
+      "disconnect",
+      () => {
+        hasExitedOrDisconnected = true
+        removeErrorListener()
+        removeExitListener()
+        resolve()
+      },
+    )
+
+    const removeExitListener = onceProcessEvent(childProcess, "exit", () => {
+      hasExitedOrDisconnected = true
+      removeErrorListener()
+      removeDisconnectListener()
       resolve()
     })
   })
 
-  const disconnectChildProcess = () => {
+  const disconnectChildProcess = async () => {
+    if (hasExitedOrDisconnected) {
+      return
+    }
     try {
       childProcess.disconnect()
     } catch (e) {
@@ -179,14 +213,20 @@ ${JSON.stringify(env, null, "  ")}`)
         throw e
       }
     }
-    return disconnected
+    await disconnected
   }
 
   const killChildProcess = async ({ signal }) => {
+    if (hasExitedOrDisconnected) {
+      await disconnectChildProcess()
+      return
+    }
+
     killing = true
     logger.debug(`send ${signal} to child process with pid ${childProcess.pid}`)
 
     await new Promise((resolve) => {
+      // see also https://github.com/sindresorhus/execa/issues/96
       const killProcessTree = require("tree-kill")
       killProcessTree(childProcess.pid, signal, (error) => {
         if (error) {
@@ -214,7 +254,7 @@ ${JSON.stringify(env, null, "  ")}`)
             return
           }
 
-          logger.error(
+          logger.warn(
             createDetailedMessage(
               `error while killing process tree with ${signal}`,
               {
@@ -237,17 +277,31 @@ ${JSON.stringify(env, null, "  ")}`)
     // in case the child process did not disconnect by itself at this point
     // something is keeping it alive and it cannot be propely killed.
     // wait for the child process to disconnect by itself
-    return disconnectChildProcess()
+    await disconnectChildProcess()
   }
 
-  const stop = ({ gracefulFailed } = {}) => {
-    return killChildProcess({
-      signal: gracefulFailed ? GRACEFUL_STOP_FAILED_SIGNAL : STOP_SIGNAL,
-    })
+  const stop = async ({ gracefulFailed } = {}) => {
+    let unregisterErrorCallback
+    await Promise.race([
+      new Promise((resolve, reject) => {
+        unregisterErrorCallback = registerErrorCallback(reject)
+      }),
+      killChildProcess({
+        signal: gracefulFailed ? GRACEFUL_STOP_FAILED_SIGNAL : STOP_SIGNAL,
+      }),
+    ])
+    unregisterErrorCallback()
   }
 
-  const gracefulStop = () => {
-    return killChildProcess({ signal: GRACEFUL_STOP_SIGNAL })
+  const gracefulStop = async () => {
+    let unregisterErrorCallback
+    await Promise.race([
+      new Promise((resolve, reject) => {
+        unregisterErrorCallback = registerErrorCallback(reject)
+      }),
+      killChildProcess({ signal: GRACEFUL_STOP_SIGNAL }),
+    ])
+    unregisterErrorCallback()
   }
 
   const requestActionOnChildProcess = ({ actionType, actionParams }) => {
@@ -338,15 +392,13 @@ const installProcessOutputListener = (childProcess, callback) => {
 
 const installProcessErrorListener = (childProcess, callback) => {
   // https://nodejs.org/api/child_process.html#child_process_event_error
-  const errorListener = (error) => {
-    removeExitListener() // if an error occured we ignore the child process exitCode
-    callback(error)
-    onceProcessMessage(childProcess, "error", errorListener)
-  }
   const removeErrorListener = onceProcessMessage(
     childProcess,
     "error",
-    errorListener,
+    (error) => {
+      removeExitListener() // if an error occured we ignore the child process exitCode
+      callback(error)
+    },
   )
   // process.exit(1) in child process or process.exitCode = 1 + process.exit()
   // means there was an error even if we don't know exactly what.

package/src/internal/node-launcher/nodeControllableFile.mjs

@@ -150,7 +150,7 @@ const removeActionRequestListener = onceProcessMessage(
     // removeActionRequestListener()
     if (actionParams.exitAfterAction) {
       // for some reason this fixes v8 coverage directory somtimes empty
-      setTimeout(() => process.exit())
+      process.exit()
     }
   },
 )