@jsenv/core 24.2.2 → 24.4.0

package/src/internal/browser_launcher/browser_runtime_report.js

@@ -0,0 +1,75 @@
+export const getBrowserRuntimeReport = async ({
+  page,
+  coverageHandledFromOutside,
+  runtime,
+  compileServerId,
+}) => {
+  const cache = cacheFromParams({
+    runtime,
+    compileServerId,
+    coverageHandledFromOutside,
+  })
+  const entry = cache.read()
+  if (entry) {
+    return entry
+  }
+  const browserRuntimeFeaturesReport = await page.evaluate(
+    /* istanbul ignore next */
+    async ({ coverageHandledFromOutside }) => {
+      // eslint-disable-next-line no-undef
+      await window.readyPromise
+
+      // eslint-disable-next-line no-undef
+      return window.scanBrowserRuntimeFeatures({
+        coverageHandledFromOutside,
+        failFastOnFeatureDetection: true,
+      })
+    },
+    { coverageHandledFromOutside },
+  )
+  cache.write(browserRuntimeFeaturesReport)
+  return browserRuntimeFeaturesReport
+}
+
+let currentCacheParams
+let currentCacheValue
+const cacheFromParams = ({
+  runtime,
+  compileServerId,
+  coverageHandledFromOutside,
+}) => {
+  const params = {
+    compileServerId,
+    coverageHandledFromOutside,
+  }
+  const runtimeLabel = `${runtime.name}/${runtime.version}`
+
+  if (!currentCacheParams) {
+    currentCacheParams = params
+    currentCacheValue = {}
+    return {
+      read: () => null,
+      write: (value) => {
+        currentCacheValue[runtimeLabel] = value
+      },
+    }
+  }
+
+  if (JSON.stringify(currentCacheParams) !== JSON.stringify(params)) {
+    return {
+      read: () => null,
+      write: (value) => {
+        currentCacheParams = params
+        currentCacheValue = {}
+        currentCacheValue[runtimeLabel] = value
+      },
+    }
+  }
+
+  return {
+    read: () => currentCacheValue[runtimeLabel],
+    write: (value) => {
+      currentCacheValue[runtimeLabel] = value
+    },
+  }
+}

package/src/internal/{browser-launcher → browser_launcher}/executeHtmlFile.js

@@ -5,18 +5,21 @@ import {
   urlToExtension,
 } from "@jsenv/filesystem"
 
-import { jsenvCompileProxyHtmlFileInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
+import { COMPILE_PROXY_BUILD_URL } from "@jsenv/core/dist/build_manifest.js"
 import { filterV8Coverage } from "@jsenv/core/src/internal/executing/coverage_utils/v8_coverage_from_directory.js"
 import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage_utils/istanbul_coverage_composition.js"
-import { evalSource } from "../runtime/createNodeRuntime/evalSource.js"
+import { evalSource } from "../node_runtime/evalSource.js"
 import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.js"
+import { getBrowserRuntimeReport } from "./browser_runtime_report.js"
 
 export const executeHtmlFile = async (
   fileRelativeUrl,
   {
+    runtime,
     executeOperation,
     projectDirectoryUrl,
     compileServerOrigin,
+    compileServerId,
     outDirectoryRelativeUrl,
     page,
 
@@ -39,7 +42,7 @@ export const executeHtmlFile = async (
   await assertFilePresence(fileUrl)
 
   const compileProxyProjectRelativeUrl = urlToRelativeUrl(
-    jsenvCompileProxyHtmlFileInfo.url,
+    COMPILE_PROXY_BUILD_URL,
     projectDirectoryUrl,
   )
   const compileProxyClientUrl = resolveUrl(
@@ -48,22 +51,16 @@ export const executeHtmlFile = async (
   )
   executeOperation.throwIfAborted()
   await page.goto(compileProxyClientUrl)
+  executeOperation.throwIfAborted()
 
   const coverageHandledFromOutside =
     coveragePlaywrightAPIAvailable && !coverageForceIstanbul
-
-  executeOperation.throwIfAborted()
-  const browserRuntimeFeaturesReport = await page.evaluate(
-    /* istanbul ignore next */
-    ({ coverageHandledFromOutside }) => {
-      // eslint-disable-next-line no-undef
-      return window.scanBrowserRuntimeFeatures({
-        coverageHandledFromOutside,
-        failFastOnFeatureDetection: true,
-      })
-    },
-    { coverageHandledFromOutside },
-  )
+  const browserRuntimeFeaturesReport = await getBrowserRuntimeReport({
+    page,
+    coverageHandledFromOutside,
+    compileServerId,
+    runtime,
+  })
 
   try {
     let executionResult

package/src/internal/browser_launcher/from_playwright.js

@@ -0,0 +1,314 @@
+// https://github.com/microsoft/playwright/blob/master/docs/api.md
+
+import { createDetailedMessage } from "@jsenv/logger"
+import {
+  Abort,
+  createCallbackListNotifiedOnce,
+  createCallbackList,
+  raceProcessTeardownEvents,
+} from "@jsenv/abort"
+import { memoize } from "@jsenv/filesystem"
+
+import { trackPageToNotify } from "./trackPageToNotify.js"
+import { executeHtmlFile } from "./executeHtmlFile.js"
+
+export const createRuntimeFromPlaywright = ({
+  browserName,
+  browserVersion,
+  coveragePlaywrightAPIAvailable = false,
+  ignoreErrorHook = () => false,
+  transformErrorHook = (error) => error,
+  tab = false,
+}) => {
+  const runtime = {
+    name: browserName,
+    version: browserVersion,
+  }
+
+  let browserAndContextPromise
+  runtime.launch = async ({
+    signal = new AbortController().signal,
+    executablePath,
+    browserServerLogLevel,
+
+    projectDirectoryUrl,
+    compileServerOrigin,
+    outDirectoryRelativeUrl,
+
+    collectPerformance,
+    measurePerformance,
+    collectCoverage,
+    coverageIgnorePredicate,
+    coverageForceIstanbul,
+
+    headless = true,
+    stopOnExit = true,
+    ignoreHTTPSErrors = true,
+    stopAfterAllExecutionCallbackList,
+  }) => {
+    const stopCallbackList = createCallbackListNotifiedOnce()
+    const stoppedCallbackList = createCallbackListNotifiedOnce()
+    const errorCallbackList = createCallbackList()
+    const outputCallbackList = createCallbackList()
+
+    const stop = memoize(async (reason) => {
+      await stopCallbackList.notify({ reason })
+      stoppedCallbackList.notify({ reason })
+      return { graceful: false }
+    })
+    const closeBrowser = async () => {
+      const { browser } = await browserAndContextPromise
+      browserAndContextPromise = null
+      await stopBrowser(browser)
+    }
+
+    if (
+      !browserAndContextPromise ||
+      !tab ||
+      !stopAfterAllExecutionCallbackList
+    ) {
+      browserAndContextPromise = (async () => {
+        const browser = await launchBrowserUsingPlaywright({
+          signal,
+          browserName,
+          stopOnExit,
+          playwrightOptions: {
+            headless,
+            executablePath,
+          },
+        })
+        const browserContext = await browser.newContext({ ignoreHTTPSErrors })
+        return { browser, browserContext }
+      })()
+
+      // when using chromium tab during multiple executions we reuse the chromium browser
+      // and only once all executions are done we close the browser
+      if (tab && stopAfterAllExecutionCallbackList) {
+        stopAfterAllExecutionCallbackList.add(async () => {
+          await closeBrowser()
+        })
+      } else {
+        stopCallbackList.add(async () => {
+          await closeBrowser()
+        })
+      }
+    }
+
+    const { browser, browserContext } = await browserAndContextPromise
+    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
+    browser.on("disconnected", () => {
+      stop()
+    })
+
+    const page = await browserContext.newPage()
+    stoppedCallbackList.add(async () => {
+      try {
+        await page.close()
+      } catch (e) {
+        if (isTargetClosedError(e)) {
+          return
+        }
+        throw e
+      }
+    })
+    const stopTrackingToNotify = trackPageToNotify(page, {
+      onError: (error) => {
+        error = transformErrorHook(error)
+        if (!ignoreErrorHook(error)) {
+          errorCallbackList.notify(error)
+        }
+      },
+      onConsole: outputCallbackList.notify,
+    })
+    stoppedCallbackList.add(stopTrackingToNotify)
+
+    const execute = createExecuteHook({
+      page,
+      runtime,
+      browserServerLogLevel,
+
+      projectDirectoryUrl,
+      compileServerOrigin,
+      outDirectoryRelativeUrl,
+
+      collectPerformance,
+      measurePerformance,
+      collectCoverage,
+      coverageIgnorePredicate,
+      coverageForceIstanbul,
+
+      coveragePlaywrightAPIAvailable,
+      transformErrorHook,
+    })
+
+    return {
+      stopCallbackList,
+      stoppedCallbackList,
+      errorCallbackList,
+      outputCallbackList,
+      execute,
+      stop,
+    }
+  }
+  if (!tab) {
+    runtime.tab = createRuntimeFromPlaywright({
+      browserName,
+      browserVersion,
+      coveragePlaywrightAPIAvailable,
+      ignoreErrorHook,
+      transformErrorHook,
+      tab: true,
+    })
+  }
+  return runtime
+}
+
+const stopBrowser = async (browser) => {
+  const disconnected = browser.isConnected()
+    ? new Promise((resolve) => {
+        const disconnectedCallback = () => {
+          browser.removeListener("disconnected", disconnectedCallback)
+          resolve()
+        }
+        browser.on("disconnected", disconnectedCallback)
+      })
+    : Promise.resolve()
+
+  // for some reason without this 100ms timeout
+  // browser.close() never resolves (playwright does not like something)
+  await new Promise((resolve) => setTimeout(resolve, 100))
+
+  try {
+    await browser.close()
+  } catch (e) {
+    if (isTargetClosedError(e)) {
+      return
+    }
+    throw e
+  }
+  await disconnected
+}
+
+const launchBrowserUsingPlaywright = async ({
+  signal,
+  browserName,
+  stopOnExit,
+  playwrightOptions,
+}) => {
+  const launchBrowserOperation = Abort.startOperation()
+  launchBrowserOperation.addAbortSignal(signal)
+  const playwright = await importPlaywright({ browserName })
+  if (stopOnExit) {
+    launchBrowserOperation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
+        {
+          SIGHUP: true,
+          SIGTERM: true,
+          SIGINT: true,
+          beforeExit: true,
+          exit: true,
+        },
+        abort,
+      )
+    })
+  }
+
+  const browserClass = playwright[browserName]
+  try {
+    const browser = await browserClass.launch({
+      ...playwrightOptions,
+      // let's handle them to close properly browser + remove listener
+      // instead of relying on playwright to do so
+      handleSIGINT: false,
+      handleSIGTERM: false,
+      handleSIGHUP: false,
+    })
+    launchBrowserOperation.throwIfAborted()
+    return browser
+  } catch (e) {
+    if (launchBrowserOperation.signal.aborted && isTargetClosedError(e)) {
+      // rethrow the abort error
+      launchBrowserOperation.throwIfAborted()
+    }
+    throw e
+  } finally {
+    await launchBrowserOperation.end()
+  }
+}
+
+const importPlaywright = async ({ browserName }) => {
+  try {
+    const namespace = await import("playwright")
+    return namespace
+  } catch (e) {
+    if (e.code === "ERR_MODULE_NOT_FOUND") {
+      throw new Error(
+        createDetailedMessage(
+          `"playwright" not found. You need playwright in your dependencies when using "${browserName}Runtime"`,
+          {
+            suggestion: `npm install --save-dev playwright`,
+          },
+        ),
+        { cause: e },
+      )
+    }
+    throw e
+  }
+}
+
+const createExecuteHook = ({
+  page,
+  runtime,
+  projectDirectoryUrl,
+  compileServerOrigin,
+  compileServerId,
+  outDirectoryRelativeUrl,
+
+  collectPerformance,
+  measurePerformance,
+  collectCoverage,
+  coverageIgnorePredicate,
+  coverageForceIstanbul,
+
+  coveragePlaywrightAPIAvailable,
+  transformErrorHook,
+}) => {
+  const execute = async ({ signal, fileRelativeUrl }) => {
+    const executeOperation = Abort.startOperation()
+    executeOperation.addAbortSignal(signal)
+    executeOperation.throwIfAborted()
+    const result = await executeHtmlFile(fileRelativeUrl, {
+      runtime,
+      executeOperation,
+
+      projectDirectoryUrl,
+      compileServerOrigin,
+      compileServerId,
+      outDirectoryRelativeUrl,
+
+      page,
+      measurePerformance,
+      collectPerformance,
+      collectCoverage,
+      coverageForceIstanbul,
+      coveragePlaywrightAPIAvailable,
+      coverageIgnorePredicate,
+      transformErrorHook,
+    })
+    return result
+  }
+  return execute
+}
+
+const isTargetClosedError = (error) => {
+  if (error.message.match(/Protocol error \(.*?\): Target closed/)) {
+    return true
+  }
+  if (error.message.match(/Protocol error \(.*?\): Browser.*?closed/)) {
+    return true
+  }
+  if (error.message.includes("browserContext.close: Browser closed")) {
+    return true
+  }
+  return false
+}

package/src/internal/{browser-launcher/jsenv-browser-system.js → browser_runtime/browser_runtime.js}

@@ -1,14 +1,14 @@
 /* eslint-env browser */
 
-import { unevalException } from "../unevalException.js"
-import { createBrowserRuntime } from "../runtime/createBrowserRuntime/createBrowserRuntime.js"
 import { installBrowserErrorStackRemapping } from "../error-stack-remapping/installBrowserErrorStackRemapping.js"
-import { fetchUrl } from "../browser-utils/fetch-browser.js"
-import { fetchAndEvalUsingFetch } from "../browser-utils/fetchAndEvalUsingFetch.js"
+import { fetchUrl } from "../browser_utils/fetch-browser.js"
+import { fetchAndEvalUsingFetch } from "../browser_utils/fetchAndEvalUsingFetch.js"
+import { unevalException } from "../unevalException.js"
 import { memoize } from "../memoize.js"
 
 import { displayErrorInDocument } from "./displayErrorInDocument.js"
 import { displayErrorNotification } from "./displayErrorNotification.js"
+import { createBrowserRuntime } from "./createBrowserRuntime.js"
 
 const getNavigationStartTime = () => {
   try {

package/src/internal/{runtime/createBrowserRuntime/createBrowserSystem.js → browser_runtime/browser_system.js}

@@ -1,6 +1,7 @@
-import { getJavaScriptModuleResponseError } from "../module-registration.js"
+/* eslint-env browser */
 
-import "../s.js"
+import { getJavaScriptModuleResponseError } from "../runtime/module-registration.js"
+import "../runtime/s.js"
 
 export const createBrowserSystem = ({
   compileServerOrigin,

package/src/internal/{runtime/createBrowserRuntime → browser_runtime}/createBrowserRuntime.js

@@ -1,12 +1,14 @@
+/* eslint-env browser */
+
 import { normalizeImportMap } from "@jsenv/importmap/src/normalizeImportMap.js"
 
 // do not use memoize from @jsenv/filesystem to avoid pulling @jsenv/filesystem code into the browser build
-import { memoize } from "../../memoize.js"
-import { fetchUrl } from "../../browser-utils/fetch-browser.js"
-import { createImportResolverForImportmap } from "../../import-resolution/import-resolver-importmap.js"
-import { measureAsyncFnPerf } from "../../perf_browser.js"
+import { fetchUrl } from "../browser_utils/fetch-browser.js"
+import { createImportResolverForImportmap } from "../import-resolution/import-resolver-importmap.js"
+import { memoize } from "../memoize.js"
+import { measureAsyncFnPerf } from "../perf_browser.js"
 
-import { createBrowserSystem } from "./createBrowserSystem.js"
+import { createBrowserSystem } from "./browser_system.js"
 import { makeNamespaceTransferable } from "./makeNamespaceTransferable.js"
 
 const memoizedCreateBrowserSystem = memoize(createBrowserSystem)

package/src/internal/{browser-launcher → browser_runtime}/displayErrorNotification.js

@@ -3,10 +3,8 @@ const { Notification } = window
 
 const displayErrorNotificationNotAvailable = () => {}
 
-const displayErrorNotificationImplementation = async (error, { icon } = {}) => {
-  const permission = await Notification.requestPermission()
-
-  if (permission === "granted") {
+const displayErrorNotificationImplementation = (error, { icon } = {}) => {
+  if (Notification.permission === "granted") {
     const notification = new Notification("An error occured", {
       lang: "en",
       body: error.stack,

package/src/internal/{runtime/createBrowserRuntime → browser_runtime}/evalSource.js

@@ -1,3 +1,5 @@
+/* eslint-env browser */
+
 export const evalSource = (code, href) => {
   // eslint-disable-next-line no-eval
   return window.eval(appendSourceURL(code, href))

package/src/internal/{browser-utils → browser_utils}/fetch-browser.js

@@ -1,3 +1,5 @@
+/* eslint-env browser */
+
 import { fetchUsingXHR } from "./fetchUsingXHR.js"
 
 const fetchNative = async (url, { mode = "cors", ...options } = {}) => {

package/src/internal/{browser-utils → browser_utils}/fetchAndEvalUsingFetch.js

@@ -1,4 +1,7 @@
+/* eslint-env browser */
+
 import { createDetailedMessage } from "@jsenv/logger"
+
 import { fetchUrl } from "./fetch-browser.js"
 
 export const fetchAndEvalUsingFetch = async (url) => {

package/src/internal/{browser-utils → browser_utils}/fetchAndEvalUsingScript.js

@@ -1,3 +1,5 @@
+/* eslint-env browser */
+
 export const fetchAndEvalUsingScript = async (src) => {
   return new Promise((resolve, reject) => {
     const script = document.createElement("script")

package/src/internal/{browser-utils → browser_utils}/fetchUsingXHR.js

@@ -1,4 +1,4 @@
-import { createDetailedMessage } from "@jsenv/logger"
+/* eslint-env browser */
 
 export const fetchUsingXHR = async (
   url,
@@ -206,9 +206,9 @@ const hasSearchParams = typeof window.URLSearchParams === "function"
 
 const createRequestError = (error, { url }) => {
   return new Error(
-    createDetailedMessage(`error during xhr request on ${url}.`, {
-      ["error stack"]: error.stack,
-    }),
+    `error during xhr request on ${url}.
+--- error stack ---
+${error.stack}`,
   )
 }
 

package/src/internal/building/buildUsingRollup.js

@@ -50,8 +50,10 @@ export const buildUsingRollup = async ({
   importPaths,
 
   urlVersioning,
+  urlVersionningForEntryPoints,
   lineBreakNormalization,
   jsConcatenation,
+  cssConcatenation,
   useImportMapToMaximizeCacheReuse,
   preserveEntrySignatures,
   treeshake,
@@ -121,8 +123,10 @@ export const buildUsingRollup = async ({
     importPaths,
 
     urlVersioning,
+    urlVersionningForEntryPoints,
     lineBreakNormalization,
     jsConcatenation,
+    cssConcatenation,
     useImportMapToMaximizeCacheReuse,
 
     minify,

package/src/internal/building/createJsenvRollupPlugin.js

@@ -12,6 +12,7 @@ import {
   urlIsInsideOf,
   normalizeStructuredMetaMap,
   urlToMeta,
+  urlToBasename,
 } from "@jsenv/filesystem"
 import { UNICODE } from "@jsenv/log"
 
@@ -72,8 +73,10 @@ export const createJsenvRollupPlugin = async ({
   importAssertionsSupport,
 
   urlVersioning,
+  urlVersionningForEntryPoints,
   lineBreakNormalization,
   jsConcatenation,
+  cssConcatenation,
   useImportMapToMaximizeCacheReuse,
 
   minify,
@@ -468,6 +471,7 @@ export const createJsenvRollupPlugin = async ({
               minifyJs,
               minifyHtml,
               minifyCssOptions,
+              cssConcatenation,
             })
           },
         },
@@ -586,9 +590,10 @@ export const createJsenvRollupPlugin = async ({
               atleastOneChunkEmitted = true
               emitChunk({
                 id: ensureRelativeUrlNotation(entryProjectRelativeUrl),
-                name: entryBuildRelativeUrl,
-                // don't hash js entry points
-                fileName: entryBuildRelativeUrl,
+                name: urlToBasename(`file:///${entryBuildRelativeUrl}`),
+                ...(urlVersionningForEntryPoints
+                  ? {}
+                  : { fileName: entryBuildRelativeUrl }),
               })
               return
             }
@@ -601,15 +606,16 @@ export const createJsenvRollupPlugin = async ({
                 `Unusual content type for entry point, got "${entryContentType}" for ${entryProjectRelativeUrl}`,
               )
             }
-            const entryUrl = resolveUrl(
-              entryProjectRelativeUrl,
-              compileServerOrigin,
-            )
+            const entryUrl =
+              entryContentType === "text/html"
+                ? resolveUrl(entryProjectRelativeUrl, compileServerOrigin)
+                : resolveUrl(entryProjectRelativeUrl, compileDirectoryRemoteUrl)
             await ressourceBuilder.createReferenceForEntryPoint({
               entryContentType,
               entryUrl,
               entryBuffer,
               entryBuildRelativeUrl,
+              urlVersionningForEntryPoints,
             })
           },
         ),
@@ -1015,6 +1021,9 @@ export const createJsenvRollupPlugin = async ({
         return id
       }
       outputOptions.entryFileNames = () => {
+        if (urlVersionningForEntryPoints) {
+          return `[name]-[hash]${outputExtension}`
+        }
         return `[name]${outputExtension}`
       }
       outputOptions.chunkFileNames = () => {
@@ -1097,7 +1106,9 @@ export const createJsenvRollupPlugin = async ({
         const file = jsChunks[fileName]
         let buildRelativeUrl
         const canBeVersioned =
-          asRollupUrl(file.url) in jsModulesFromEntry || !file.isEntry
+          asRollupUrl(file.url) in jsModulesFromEntry ||
+          urlVersionningForEntryPoints ||
+          !file.isEntry
 
         if (urlVersioning) {
           if (canBeVersioned && useImportMapToMaximizeCacheReuse) {
@@ -1133,7 +1144,6 @@ export const createJsenvRollupPlugin = async ({
           buildInlineFileContents[buildRelativeUrl] = file.code
         } else {
           markBuildRelativeUrlAsUsedByJs(buildRelativeUrl)
-          buildManifest[fileName] = buildRelativeUrl
           buildMappings[originalProjectRelativeUrl] = buildRelativeUrl
         }
       })