@jsenv/core 23.1.3 → 23.2.2

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

@@ -5,6 +5,7 @@ import {
   urlToExtension,
 } from "@jsenv/filesystem"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
 import { jsenvCompileProxyHtmlFileInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
 import { v8CoverageFromAllV8Coverages } from "@jsenv/core/src/internal/executing/coverage/v8CoverageFromAllV8Coverages.js"
 import { composeIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage/composeIstanbulCoverages.js"
@@ -14,7 +15,7 @@ import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.
 export const executeHtmlFile = async (
   fileRelativeUrl,
   {
-    cancellationToken,
+    launchBrowserOperation,
     projectDirectoryUrl,
     compileServerOrigin,
     outDirectoryRelativeUrl,
@@ -26,6 +27,7 @@ export const executeHtmlFile = async (
     coverageConfig,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable,
+    transformErrorHook,
   },
 ) => {
   const fileUrl = resolveUrl(fileRelativeUrl, projectDirectoryUrl)
@@ -45,11 +47,13 @@ export const executeHtmlFile = async (
     compileProxyProjectRelativeUrl,
     compileServerOrigin,
   )
+  Abortable.throwIfAborted(launchBrowserOperation)
   await page.goto(compileProxyClientUrl)
 
   const coverageHandledFromOutside =
     coveragePlaywrightAPIAvailable && !coverageForceIstanbul
 
+  Abortable.throwIfAborted(launchBrowserOperation)
   const browserRuntimeFeaturesReport = await page.evaluate(
     /* istanbul ignore next */
     ({ coverageHandledFromOutside }) => {
@@ -65,6 +69,7 @@ export const executeHtmlFile = async (
   try {
     let executionResult
     const { canAvoidCompilation, compileId } = browserRuntimeFeaturesReport
+    Abortable.throwIfAborted(launchBrowserOperation)
     if (canAvoidCompilation) {
       executionResult = await executeSource({
         projectDirectoryUrl,
@@ -73,6 +78,7 @@ export const executeHtmlFile = async (
         page,
         collectCoverage,
         coverageConfig,
+        transformErrorHook,
       })
     } else {
       executionResult = await executeCompiledVersion({
@@ -83,6 +89,7 @@ export const executeHtmlFile = async (
         outDirectoryRelativeUrl,
         compileId,
         collectCoverage,
+        transformErrorHook,
       })
     }
 
@@ -114,19 +121,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 (launchBrowserOperation.signal.aborted && isBrowserClosedError(error)) {
+      Abortable.throwIfAborted(launchBrowserOperation)
     }
+    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 +151,7 @@ const executeSource = async ({
   page,
   collectCoverage,
   coverageConfig,
+  transformErrorHook,
 }) => {
   let transformResult = (result) => result
 
@@ -196,6 +212,7 @@ const executeSource = async ({
     const error = evalException(exceptionSource, {
       projectDirectoryUrl,
       compileServerOrigin,
+      transformErrorHook,
     })
     return transformResult({
       status: "errored",
@@ -218,6 +235,7 @@ const executeCompiledVersion = async ({
   outDirectoryRelativeUrl,
   compileId,
   collectCoverage,
+  transformErrorHook,
 }) => {
   let transformResult = (result) => result
   if (collectCoverage) {
@@ -264,6 +282,7 @@ const executeCompiledVersion = async ({
     const error = evalException(exceptionSource, {
       projectDirectoryUrl,
       compileServerOrigin,
+      transformErrorHook,
     })
     return transformResult({
       status: "errored",
@@ -292,9 +311,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 +322,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,12 +1,14 @@
-import { createOperation } from "@jsenv/cancellation"
 import {
   urlToFileSystemPath,
   ensureEmptyDirectory,
   readFile,
   urlToRelativeUrl,
+  writeFile,
+  resolveUrl,
 } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
 import { buildServiceWorker } from "@jsenv/core/src/internal/building/buildServiceWorker.js"
 import { humanizeUrl } from "@jsenv/core/src/internal/building/url_trace.js"
 import {
@@ -17,7 +19,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 +103,7 @@ export const buildUsingRollup = async ({
     asOriginalUrl,
     asProjectUrl,
   } = await createJsenvRollupPlugin({
-    cancellationToken,
+    buildOperation,
     logger,
 
     projectDirectoryUrl,
@@ -109,9 +111,6 @@ export const buildUsingRollup = async ({
     compileServerOrigin,
     compileDirectoryRelativeUrl,
     buildDirectoryUrl,
-    assetManifestFile,
-    assetManifestFileRelativeUrl,
-    writeOnFileSystem,
 
     format,
     systemJsUrl,
@@ -142,7 +141,7 @@ export const buildUsingRollup = async ({
 
   try {
     await useRollup({
-      cancellationToken,
+      buildOperation,
       logger,
 
       jsenvRollupPlugin,
@@ -189,9 +188,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 +234,9 @@ export const buildUsingRollup = async ({
             serviceWorkerProjectRelativeUrl,
             serviceWorkerBuildRelativeUrl,
             serviceWorkerTransformer: (code) =>
-              serviceWorkerFinalizer(code, jsenvBuild, {
+              serviceWorkerFinalizer(code, {
+                buildManifest,
+                rollupBuild,
                 lineBreakNormalization,
               }),
 
@@ -214,11 +247,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 +270,9 @@ const useRollup = async ({
   preserveEntrySignatures,
   // jsConcatenation,
   buildDirectoryUrl,
-  buildDirectoryClean,
   asOriginalUrl,
 }) => {
+  Abortable.throwIfAborted(buildOperation)
   const { rollup } = await import("rollup")
   const { importAssertions } = await import("acorn-import-assertions")
 
@@ -308,19 +350,13 @@ const useRollup = async ({
       : {}),
   }
 
-  const rollupReturnValue = await createOperation({
-    cancellationToken,
-    start: () => rollup(rollupInputOptions),
-  })
+  Abortable.throwIfAborted(buildOperation)
+  const rollupReturnValue = await rollup(rollupInputOptions)
 
-  if (buildDirectoryClean) {
-    await ensureEmptyDirectory(buildDirectoryUrl)
-  }
-
-  const rollupOutputArray = await createOperation({
-    cancellationToken,
-    start: () => rollupReturnValue.generate(rollupOutputOptions),
-  })
+  Abortable.throwIfAborted(buildOperation)
+  const rollupOutputArray = await rollupReturnValue.generate(
+    rollupOutputOptions,
+  )
 
   return rollupOutputArray
 }

package/src/internal/building/createJsenvRollupPlugin.js

@@ -9,7 +9,6 @@ import {
   resolveUrl,
   urlToRelativeUrl,
   resolveDirectoryUrl,
-  writeFile,
   comparePathnames,
   urlIsInsideOf,
   normalizeStructuredMetaMap,
@@ -17,6 +16,7 @@ import {
 } from "@jsenv/filesystem"
 import { createWorkersForJavaScriptModules } from "@jsenv/workers"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
 import { createUrlConverter } from "@jsenv/core/src/internal/url_conversion.js"
 import { createUrlFetcher } from "@jsenv/core/src/internal/building/url_fetcher.js"
 import { createUrlLoader } from "@jsenv/core/src/internal/building/url_loader.js"
@@ -50,7 +50,7 @@ import { injectSourcemapInRollupBuild } from "./rollup_build_sourcemap.js"
 import { createBuildStats } from "./build_stats.js"
 
 export const createJsenvRollupPlugin = async ({
-  cancellationToken,
+  buildOperation,
   logger,
 
   projectDirectoryUrl,
@@ -58,9 +58,6 @@ export const createJsenvRollupPlugin = async ({
   compileServerOrigin,
   compileDirectoryRelativeUrl,
   buildDirectoryUrl,
-  assetManifestFile,
-  assetManifestFileRelativeUrl,
-  writeOnFileSystem,
 
   urlMappings,
   importResolutionMethod,
@@ -755,11 +752,17 @@ export const createJsenvRollupPlugin = async ({
       }
 
       let url = asServerUrl(rollupUrl)
-      const loadResult = await urlLoader.loadUrl(rollupUrl, {
-        cancellationToken,
-        logger,
-        ressourceBuilder,
-      })
+
+      const loadResult = await Abortable.asyncCallback(
+        buildOperation,
+        (signal) => {
+          return urlLoader.loadUrl(rollupUrl, {
+            signal,
+            logger,
+            ressourceBuilder,
+          })
+        },
+      )
 
       url = loadResult.url
       const code = loadResult.code
@@ -1266,27 +1269,6 @@ export const createJsenvRollupPlugin = async ({
         buildDuration,
       })
 
-      if (assetManifestFile) {
-        const assetManifestFileUrl = resolveUrl(
-          assetManifestFileRelativeUrl,
-          buildDirectoryUrl,
-        )
-        await writeFile(
-          assetManifestFileUrl,
-          JSON.stringify(buildManifest, null, "  "),
-        )
-      }
-
-      if (writeOnFileSystem) {
-        const buildRelativeUrls = Object.keys(buildFileContents)
-        await Promise.all(
-          buildRelativeUrls.map(async (buildRelativeUrl) => {
-            const fileBuildUrl = resolveUrl(buildRelativeUrl, buildDirectoryUrl)
-            await writeFile(fileBuildUrl, buildFileContents[buildRelativeUrl])
-          }),
-        )
-      }
-
       logger.info(
         formatBuildDoneInfo({
           buildStats,

package/src/internal/building/ressource_builder.js

@@ -9,7 +9,7 @@ import {
 import { createLogger } from "@jsenv/logger"
 
 import { setJavaScriptSourceMappingUrl } from "@jsenv/core/src/internal/sourceMappingURLUtils.js"
-import { promiseTrackRace } from "../promise_track_race.js"
+import { racePromises } from "../promise_race.js"
 import { parseDataUrl } from "../dataUrl.utils.js"
 
 import {
@@ -400,11 +400,8 @@ export const createRessourceBuilder = (
         //    and this asset builder fetching to avoid fetching twice.
         //    This scenario would be reproduced for every js module preloaded
         const { usedPromise, rollupBuildDonePromise } = ressource
-        const { winner } = await promiseTrackRace([
-          usedPromise,
-          rollupBuildDonePromise,
-        ])
-        if (winner === rollupBuildDonePromise) {
+        const winner = await racePromises([usedPromise, rollupBuildDonePromise])
+        if (winner.promise === rollupBuildDonePromise) {
           return
         }
       }

package/src/internal/building/sourcemap_loader.js

@@ -1,6 +1,5 @@
-import { createCancellationToken } from "@jsenv/cancellation"
 import { resolveUrl } from "@jsenv/filesystem"
-import { createLogger, createDetailedMessage } from "@jsenv/logger"
+import { createDetailedMessage } from "@jsenv/logger"
 
 import {
   dataUrlToRawData,
@@ -10,8 +9,8 @@ import { fetchUrl } from "@jsenv/core/src/internal/fetchUrl.js"
 import { validateResponse } from "@jsenv/core/src/internal/response_validation.js"
 
 export const loadSourcemap = async ({
-  cancellationToken = createCancellationToken(),
-  logger = createLogger(),
+  signal,
+  logger,
 
   code,
   url,
@@ -33,7 +32,7 @@ export const loadSourcemap = async ({
   }
 
   const sourcemapResponse = await fetchUrl(sourcemapUrl, {
-    cancellationToken,
+    signal,
     ignoreHttpsError: true,
   })
   const { isValid, details } = await validateResponse(sourcemapResponse, {

package/src/internal/building/url_fetcher.js

@@ -13,14 +13,11 @@ export const createUrlFetcher = ({
 }) => {
   const urlRedirectionMap = {}
 
-  const fetchUrl = async (
-    url,
-    { cancellationToken, urlTrace, contentTypeExpected },
-  ) => {
+  const fetchUrl = async (url, { signal, urlTrace, contentTypeExpected }) => {
     const urlToFetch = applyUrlMappings(url)
 
     const response = await jsenvFetchUrl(urlToFetch, {
-      cancellationToken,
+      signal,
       ignoreHttpsError: true,
     })
     const responseUrl = response.url

package/src/internal/building/url_loader.js

@@ -21,10 +21,7 @@ export const createUrlLoader = ({
 }) => {
   const urlResponseBodyMap = {}
 
-  const loadUrl = async (
-    rollupUrl,
-    { cancellationToken, logger, ressourceBuilder },
-  ) => {
+  const loadUrl = async (rollupUrl, { signal, logger, ressourceBuilder }) => {
     let url = asServerUrl(rollupUrl)
     const { importType, urlWithoutImportType } = extractImportTypeFromUrl(url)
 
@@ -133,7 +130,7 @@ export const createUrlLoader = ({
     }
 
     const response = await urlFetcher.fetchUrl(url, {
-      cancellationToken,
+      signal,
       contentTypeExpected: [
         "application/javascript",
         ...(allowJson ? ["application/json"] : []),
@@ -154,7 +151,7 @@ export const createUrlLoader = ({
       const jsText = await response.text()
       saveUrlResponseBody(response.url, jsText)
       const map = await loadSourcemap({
-        cancellationToken,
+        signal,
         logger,
 
         url,

package/src/internal/compiling/compileFile.js

@@ -1,16 +1,15 @@
-import { convertFileSystemErrorToResponseProperties } from "@jsenv/server"
 import {
   urlToRelativeUrl,
   fileSystemPathToUrl,
   resolveUrl,
   bufferToEtag,
 } from "@jsenv/filesystem"
+import { convertFileSystemErrorToResponseProperties } from "@jsenv/server/src/internal/convertFileSystemErrorToResponseProperties.js"
 
 import { getOrGenerateCompiledFile } from "./compile-directory/getOrGenerateCompiledFile.js"
 import { updateMeta } from "./compile-directory/updateMeta.js"
 
 export const compileFile = async ({
-  // cancellatioToken,
   logger,
 
   projectDirectoryUrl,

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,8 +31,7 @@ const jsenvCompilers = {
 }
 
 export const createCompiledFileService = ({
-  sourceFileService,
-  cancellationToken,
+  compileServerOperation,
   logger,
 
   projectDirectoryUrl,
@@ -81,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
@@ -111,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
@@ -133,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}`,
       })
@@ -141,7 +140,7 @@ export const createCompiledFileService = ({
 
     // compile this if needed
     const compileResponsePromise = compileFile({
-      cancellationToken,
+      compileServerOperation,
       logger,
 
       projectDirectoryUrl,
@@ -153,9 +152,9 @@ export const createCompiledFileService = ({
       compileCacheStrategy,
       projectFileRequestedCallback,
       request,
-      compile: ({ code, map }) => {
+      compile: ({ signal, code, map }) => {
         return compiler({
-          cancellationToken,
+          signal,
           logger,
 
           code,