@jsenv/core 23.1.4 → 23.3.0

package/src/executeTestPlan.js

@@ -1,8 +1,3 @@
-/* eslint-disable import/max-dependencies */
-import {
-  createCancellationToken,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
 import {
   normalizeStructuredMetaMap,
   urlToFileSystemPath,
@@ -13,7 +8,6 @@ import {
 } from "@jsenv/filesystem"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 
-import { executeJsenvAsyncFunction } from "./internal/executeJsenvAsyncFunction.js"
 import {
   assertProjectDirectoryUrl,
   assertProjectDirectoryExists,
@@ -26,11 +20,11 @@ import { generateCoverageTextLog } from "./internal/executing/coverage/generateC
 import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
 
 export const executeTestPlan = async ({
+  signal = new AbortController().signal,
+  handleSIGINT = true,
   logLevel = "info",
   compileServerLogLevel = "warn",
   launchAndExecuteLogLevel = "warn",
-  cancellationToken = createCancellationToken(),
-  cancelOnSIGINT = false,
 
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
@@ -40,7 +34,7 @@ export const executeTestPlan = async ({
   testPlan,
   defaultMsAllocatedPerExecution,
 
-  concurrencyLimit,
+  maxExecutionsInParallel,
 
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
@@ -80,117 +74,107 @@ export const executeTestPlan = async ({
   customCompilers,
   jsenvDirectoryClean,
 }) => {
-  const jsenvExecuteTestPlanFunction = async ({ jsenvCancellationToken }) => {
-    cancellationToken = composeCancellationToken(
-      cancellationToken,
-      jsenvCancellationToken,
-    )
-
-    const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel })
 
-    cancellationToken.register((cancelError) => {
-      if (cancelError.reason === "process SIGINT") {
-        logger.info(`process SIGINT -> cancelling test execution`)
-      }
-    })
+  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
+  await assertProjectDirectoryExists({ projectDirectoryUrl })
 
-    projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-    await assertProjectDirectoryExists({ projectDirectoryUrl })
+  if (typeof testPlan !== "object") {
+    throw new Error(`testPlan must be an object, got ${testPlan}`)
+  }
 
-    if (typeof testPlan !== "object") {
-      throw new Error(`testPlan must be an object, got ${testPlan}`)
+  if (coverage) {
+    if (typeof coverageConfig !== "object") {
+      throw new TypeError(
+        `coverageConfig must be an object, got ${coverageConfig}`,
+      )
     }
-
-    if (coverage) {
-      if (typeof coverageConfig !== "object") {
-        throw new TypeError(
-          `coverageConfig must be an object, got ${coverageConfig}`,
-        )
-      }
-      if (Object.keys(coverageConfig).length === 0) {
-        logger.warn(
-          `coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`,
-        )
-      }
-      if (!coverageAndExecutionAllowed) {
-        const structuredMetaMapForExecute = normalizeStructuredMetaMap(
-          {
-            execute: testPlan,
-          },
-          "file:///",
-        )
-        const structuredMetaMapForCover = normalizeStructuredMetaMap(
-          {
-            cover: coverageConfig,
-          },
-          "file:///",
+    if (Object.keys(coverageConfig).length === 0) {
+      logger.warn(
+        `coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`,
+      )
+    }
+    if (!coverageAndExecutionAllowed) {
+      const structuredMetaMapForExecute = normalizeStructuredMetaMap(
+        {
+          execute: testPlan,
+        },
+        "file:///",
+      )
+      const structuredMetaMapForCover = normalizeStructuredMetaMap(
+        {
+          cover: coverageConfig,
+        },
+        "file:///",
+      )
+      const patternsMatchingCoverAndExecute = Object.keys(
+        structuredMetaMapForExecute.execute,
+      ).filter((testPlanPattern) => {
+        return urlToMeta({
+          url: testPlanPattern,
+          structuredMetaMap: structuredMetaMapForCover,
+        }).cover
+      })
+
+      if (patternsMatchingCoverAndExecute.length) {
+        // I think it is an error, it would be strange, for a given file
+        // to be both covered and executed
+        throw new Error(
+          createDetailedMessage(`some file will be both covered and executed`, {
+            patterns: patternsMatchingCoverAndExecute,
+          }),
         )
-        const patternsMatchingCoverAndExecute = Object.keys(
-          structuredMetaMapForExecute.execute,
-        ).filter((testPlanPattern) => {
-          return urlToMeta({
-            url: testPlanPattern,
-            structuredMetaMap: structuredMetaMapForCover,
-          }).cover
-        })
-
-        if (patternsMatchingCoverAndExecute.length) {
-          // I think it is an error, it would be strange, for a given file
-          // to be both covered and executed
-          throw new Error(
-            createDetailedMessage(
-              `some file will be both covered and executed`,
-              {
-                patterns: patternsMatchingCoverAndExecute,
-              },
-            ),
-          )
-        }
       }
     }
+  }
 
-    const result = await executePlan(testPlan, {
-      logger,
-      compileServerLogLevel,
-      launchAndExecuteLogLevel,
-      cancellationToken,
-
-      projectDirectoryUrl,
-      jsenvDirectoryRelativeUrl,
-
-      importResolutionMethod,
-      importDefaultExtension,
-
-      defaultMsAllocatedPerExecution,
-      concurrencyLimit,
-      completedExecutionLogMerging,
-      completedExecutionLogAbbreviation,
-      logSummary,
-      measureGlobalDuration,
-
-      coverage,
-      coverageConfig,
-      coverageIncludeMissing,
-      coverageForceIstanbul,
-      coverageV8MergeConflictIsExpected,
-
-      jsenvDirectoryClean,
-      compileServerProtocol,
-      compileServerPrivateKey,
-      compileServerCertificate,
-      compileServerIp,
-      compileServerPort,
-      compileServerCanReadFromFilesystem,
-      compileServerCanWriteOnFilesystem,
-      babelPluginMap,
-      babelConfigFileUrl,
-      customCompilers,
-    })
-
-    if (updateProcessExitCode && !executionIsPassed(result)) {
-      process.exitCode = 1
-    }
+  const result = await executePlan(testPlan, {
+    signal,
+    handleSIGINT,
+
+    logger,
+    compileServerLogLevel,
+    launchAndExecuteLogLevel,
+
+    projectDirectoryUrl,
+    jsenvDirectoryRelativeUrl,
+
+    importResolutionMethod,
+    importDefaultExtension,
+
+    defaultMsAllocatedPerExecution,
+    maxExecutionsInParallel,
+    completedExecutionLogMerging,
+    completedExecutionLogAbbreviation,
+    logSummary,
+    measureGlobalDuration,
+
+    coverage,
+    coverageConfig,
+    coverageIncludeMissing,
+    coverageForceIstanbul,
+    coverageV8MergeConflictIsExpected,
+
+    jsenvDirectoryClean,
+    compileServerProtocol,
+    compileServerPrivateKey,
+    compileServerCertificate,
+    compileServerIp,
+    compileServerPort,
+    compileServerCanReadFromFilesystem,
+    compileServerCanWriteOnFilesystem,
+    babelPluginMap,
+    babelConfigFileUrl,
+    customCompilers,
+  })
+
+  if (updateProcessExitCode && !executionIsPassed(result)) {
+    process.exitCode = 1
+  }
 
+  const planCoverage = result.planCoverage
+  // planCoverage can be null when execution is abortes
+  if (planCoverage) {
     const promises = []
     // keep this one first because it does ensureEmptyDirectory
     // and in case coverage json file gets written in the same directory
@@ -208,7 +192,7 @@ export const executeTestPlan = async ({
         )
       }
       promises.push(
-        generateCoverageHtmlDirectory(result.planCoverage, {
+        generateCoverageHtmlDirectory(planCoverage, {
           projectDirectoryUrl,
           coverageHtmlDirectoryRelativeUrl,
         }),
@@ -219,11 +203,13 @@ export const executeTestPlan = async ({
         coverageJsonFileRelativeUrl,
         projectDirectoryUrl,
       )
-      if (coverageJsonFileLog) {
-        logger.info(`-> ${urlToFileSystemPath(coverageJsonFileUrl)}`)
-      }
       promises.push(
-        generateCoverageJsonFile(result.planCoverage, coverageJsonFileUrl),
+        generateCoverageJsonFile({
+          coverage: result.planCoverage,
+          coverageJsonFileUrl,
+          coverageJsonFileLog,
+          logger,
+        }),
       )
     }
     if (coverage && coverageTextLog) {
@@ -235,15 +221,11 @@ export const executeTestPlan = async ({
       )
     }
     await Promise.all(promises)
-
-    return {
-      testPlanSummary: result.planSummary,
-      testPlanReport: result.planReport,
-      testPlanCoverage: result.planCoverage,
-    }
   }
 
-  return executeJsenvAsyncFunction(jsenvExecuteTestPlanFunction, {
-    cancelOnSIGINT,
-  })
+  return {
+    testPlanSummary: result.planSummary,
+    testPlanReport: result.planReport,
+    testPlanCoverage: planCoverage,
+  }
 }

package/src/importUsingChildProcess.js

@@ -36,10 +36,11 @@ export const importUsingChildProcess = async (
 
         return {
           ...controllableNodeProcess,
-          execute: async () => {
+          execute: async ({ signal }) => {
             try {
               const namespace =
                 await controllableNodeProcess.requestActionOnChildProcess({
+                  signal,
                   actionType: "execute-using-import",
                   actionParams: { fileUrl },
                 })

package/src/internal/browser-launcher/executeHtmlFile.js

@@ -14,7 +14,7 @@ import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.
 export const executeHtmlFile = async (
   fileRelativeUrl,
   {
-    cancellationToken,
+    executeOperation,
     projectDirectoryUrl,
     compileServerOrigin,
     outDirectoryRelativeUrl,
@@ -26,6 +26,7 @@ export const executeHtmlFile = async (
     coverageConfig,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable,
+    transformErrorHook,
   },
 ) => {
   const fileUrl = resolveUrl(fileRelativeUrl, projectDirectoryUrl)
@@ -45,11 +46,13 @@ export const executeHtmlFile = async (
     compileProxyProjectRelativeUrl,
     compileServerOrigin,
   )
+  executeOperation.throwIfAborted()
   await page.goto(compileProxyClientUrl)
 
   const coverageHandledFromOutside =
     coveragePlaywrightAPIAvailable && !coverageForceIstanbul
 
+  executeOperation.throwIfAborted()
   const browserRuntimeFeaturesReport = await page.evaluate(
     /* istanbul ignore next */
     ({ coverageHandledFromOutside }) => {
@@ -65,6 +68,7 @@ export const executeHtmlFile = async (
   try {
     let executionResult
     const { canAvoidCompilation, compileId } = browserRuntimeFeaturesReport
+    executeOperation.throwIfAborted()
     if (canAvoidCompilation) {
       executionResult = await executeSource({
         projectDirectoryUrl,
@@ -73,6 +77,7 @@ export const executeHtmlFile = async (
         page,
         collectCoverage,
         coverageConfig,
+        transformErrorHook,
       })
     } else {
       executionResult = await executeCompiledVersion({
@@ -83,6 +88,7 @@ export const executeHtmlFile = async (
         outDirectoryRelativeUrl,
         compileId,
         collectCoverage,
+        transformErrorHook,
       })
     }
 
@@ -114,19 +120,27 @@ export const executeHtmlFile = async (
     }
 
     return executionResult
-  } catch (e) {
-    // if browser is closed due to cancellation
+  } catch (error) {
+    // if browser is closed due to abort
     // before it is able to finish evaluate we can safely ignore
-    // and rethrow with current cancelError
-    if (
-      e.message.match(/^Protocol error \(.*?\): Target closed/) &&
-      cancellationToken.cancellationRequested
-    ) {
-      cancellationToken.throwIfRequested()
+    // and rethrow with current abort error
+    if (executeOperation.signal.aborted && isBrowserClosedError(error)) {
+      executeOperation.throwIfAborted()
     }
+    throw error
+  }
+}
+
+const isBrowserClosedError = (error) => {
+  if (error.message.match(/browserContext.newPage: Browser closed/)) {
+    return true
+  }
 
-    throw e
+  if (error.message.match(/^Protocol error \(.*?\): Target closed/)) {
+    return true
   }
+
+  return false
 }
 
 const executeSource = async ({
@@ -136,6 +150,7 @@ const executeSource = async ({
   page,
   collectCoverage,
   coverageConfig,
+  transformErrorHook,
 }) => {
   let transformResult = (result) => result
 
@@ -196,6 +211,7 @@ const executeSource = async ({
     const error = evalException(exceptionSource, {
       projectDirectoryUrl,
       compileServerOrigin,
+      transformErrorHook,
     })
     return transformResult({
       status: "errored",
@@ -218,6 +234,7 @@ const executeCompiledVersion = async ({
   outDirectoryRelativeUrl,
   compileId,
   collectCoverage,
+  transformErrorHook,
 }) => {
   let transformResult = (result) => result
   if (collectCoverage) {
@@ -264,6 +281,7 @@ const executeCompiledVersion = async ({
     const error = evalException(exceptionSource, {
       projectDirectoryUrl,
       compileServerOrigin,
+      transformErrorHook,
     })
     return transformResult({
       status: "errored",
@@ -292,9 +310,9 @@ const generateCoverageForPage = (fileExecutionResultMap) => {
 
 const evalException = (
   exceptionSource,
-  { projectDirectoryUrl, compileServerOrigin },
+  { projectDirectoryUrl, compileServerOrigin, transformErrorHook },
 ) => {
-  const error = evalSource(exceptionSource)
+  let error = evalSource(exceptionSource)
 
   if (error && error instanceof Error) {
     const remoteRootRegexp = new RegExp(
@@ -303,6 +321,8 @@ const evalException = (
     )
     error.stack = error.stack.replace(remoteRootRegexp, projectDirectoryUrl)
     error.message = error.message.replace(remoteRootRegexp, projectDirectoryUrl)
+
+    error = transformErrorHook(error)
   }
 
   return error

package/src/internal/browser-utils/fetch-browser.js

@@ -1,36 +1,11 @@
-import { createCancellationToken } from "@jsenv/cancellation/main.browser.js"
 import { fetchUsingXHR } from "./fetchUsingXHR.js"
 
-const fetchNative = async (
-  url,
-  {
-    cancellationToken = createCancellationToken(),
-    mode = "cors",
-    ...options
-  } = {},
-) => {
-  const abortController = new AbortController()
-
-  let cancelError
-  cancellationToken.register((reason) => {
-    cancelError = reason
-    abortController.abort(reason)
+const fetchNative = async (url, { mode = "cors", ...options } = {}) => {
+  const response = await window.fetch(url, {
+    mode,
+    ...options,
   })
 
-  let response
-  try {
-    response = await window.fetch(url, {
-      signal: abortController.signal,
-      mode,
-      ...options,
-    })
-  } catch (e) {
-    if (cancelError && e.name === "AbortError") {
-      throw cancelError
-    }
-    throw e
-  }
-
   return {
     url: response.url,
     status: response.status,

package/src/internal/browser-utils/fetchUsingXHR.js

@@ -1,13 +1,9 @@
-import { createCancellationToken } from "@jsenv/cancellation/main.browser.js"
 import { createDetailedMessage } from "@jsenv/logger"
-// ideally we should do some window.fetch detection (ensuring it has cancellation) and accordingly
-// fallback to this polyfill (or even use an existing polyfill would be better)
-// https://github.com/github/fetch/blob/master/fetch.js
 
 export const fetchUsingXHR = async (
   url,
   {
-    cancellationToken = createCancellationToken(),
+    signal,
     method = "GET",
     credentials = "same-origin",
     headers = {},
@@ -52,9 +48,11 @@ export const fetchUsingXHR = async (
     bodyPromise.resolve()
   }
 
-  cancellationToken.register((cancelError) => {
+  signal.addEventListener("abort", () => {
     xhr.abort()
-    failure(cancelError)
+    const abortError = new Error("aborted")
+    abortError.name = "AbortError"
+    failure(abortError)
   })
 
   xhr.onreadystatechange = () => {

package/src/internal/building/buildUsingRollup.js

@@ -1,9 +1,10 @@
-import { createOperation } from "@jsenv/cancellation"
 import {
   urlToFileSystemPath,
   ensureEmptyDirectory,
   readFile,
   urlToRelativeUrl,
+  writeFile,
+  resolveUrl,
 } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 
@@ -17,7 +18,7 @@ import { createRuntimeCompat } from "@jsenv/core/src/internal/generateGroupMap/r
 import { createJsenvRollupPlugin } from "./createJsenvRollupPlugin.js"
 
 export const buildUsingRollup = async ({
-  cancellationToken,
+  buildOperation,
   logger,
 
   projectDirectoryUrl,
@@ -101,7 +102,7 @@ export const buildUsingRollup = async ({
     asOriginalUrl,
     asProjectUrl,
   } = await createJsenvRollupPlugin({
-    cancellationToken,
+    buildOperation,
     logger,
 
     projectDirectoryUrl,
@@ -109,9 +110,6 @@ export const buildUsingRollup = async ({
     compileServerOrigin,
     compileDirectoryRelativeUrl,
     buildDirectoryUrl,
-    assetManifestFile,
-    assetManifestFileRelativeUrl,
-    writeOnFileSystem,
 
     format,
     systemJsUrl,
@@ -142,7 +140,7 @@ export const buildUsingRollup = async ({
 
   try {
     await useRollup({
-      cancellationToken,
+      buildOperation,
       logger,
 
       jsenvRollupPlugin,
@@ -189,9 +187,41 @@ export const buildUsingRollup = async ({
     throw e
   }
 
-  const jsenvBuild = getResult()
+  const {
+    rollupBuild,
+    urlResponseBodyMap,
+    buildMappings,
+    buildManifest,
+    buildImportMap,
+    buildFileContents,
+    buildInlineFileContents,
+    buildStats,
+  } = getResult()
 
   if (writeOnFileSystem) {
+    if (buildDirectoryClean) {
+      await ensureEmptyDirectory(buildDirectoryUrl)
+    }
+
+    if (assetManifestFile) {
+      const assetManifestFileUrl = resolveUrl(
+        assetManifestFileRelativeUrl,
+        buildDirectoryUrl,
+      )
+      await writeFile(
+        assetManifestFileUrl,
+        JSON.stringify(buildManifest, null, "  "),
+      )
+    }
+
+    const buildRelativeUrls = Object.keys(buildFileContents)
+    await Promise.all(
+      buildRelativeUrls.map(async (buildRelativeUrl) => {
+        const fileBuildUrl = resolveUrl(buildRelativeUrl, buildDirectoryUrl)
+        await writeFile(fileBuildUrl, buildFileContents[buildRelativeUrl])
+      }),
+    )
+
     await Promise.all(
       Object.keys(serviceWorkers).map(
         async (serviceWorkerProjectRelativeUrl) => {
@@ -203,7 +233,9 @@ export const buildUsingRollup = async ({
             serviceWorkerProjectRelativeUrl,
             serviceWorkerBuildRelativeUrl,
             serviceWorkerTransformer: (code) =>
-              serviceWorkerFinalizer(code, jsenvBuild, {
+              serviceWorkerFinalizer(code, {
+                buildManifest,
+                rollupBuild,
                 lineBreakNormalization,
               }),
 
@@ -214,11 +246,20 @@ export const buildUsingRollup = async ({
     )
   }
 
-  return jsenvBuild
+  return {
+    rollupBuild,
+    urlResponseBodyMap,
+    buildMappings,
+    buildManifest,
+    buildImportMap,
+    buildFileContents,
+    buildInlineFileContents,
+    buildStats,
+  }
 }
 
 const useRollup = async ({
-  cancellationToken,
+  buildOperation,
   logger,
   jsenvRollupPlugin,
   format,
@@ -228,9 +269,9 @@ const useRollup = async ({
   preserveEntrySignatures,
   // jsConcatenation,
   buildDirectoryUrl,
-  buildDirectoryClean,
   asOriginalUrl,
 }) => {
+  buildOperation.throwIfAborted()
   const { rollup } = await import("rollup")
   const { importAssertions } = await import("acorn-import-assertions")
 
@@ -308,19 +349,13 @@ const useRollup = async ({
       : {}),
   }
 
-  const rollupReturnValue = await createOperation({
-    cancellationToken,
-    start: () => rollup(rollupInputOptions),
-  })
+  buildOperation.throwIfAborted()
+  const rollupReturnValue = await rollup(rollupInputOptions)
 
-  if (buildDirectoryClean) {
-    await ensureEmptyDirectory(buildDirectoryUrl)
-  }
-
-  const rollupOutputArray = await createOperation({
-    cancellationToken,
-    start: () => rollupReturnValue.generate(rollupOutputOptions),
-  })
+  buildOperation.throwIfAborted()
+  const rollupOutputArray = await rollupReturnValue.generate(
+    rollupOutputOptions,
+  )
 
   return rollupOutputArray
 }