@jsenv/test 1.0.0

package/src/runtime_browsers/chromium.js

@@ -0,0 +1,24 @@
+import { createRuntimeUsingPlaywright } from "./using_playwright.js"
+
+const chromiumParams = {
+  browserName: "chromium",
+  // browserVersion will be set by "browser._initializer.version"
+  // see also https://github.com/microsoft/playwright/releases
+  browserVersion: "unset",
+  coveragePlaywrightAPIAvailable: true,
+}
+
+export const chromium = (params) => {
+  return createRuntimeUsingPlaywright({
+    ...chromiumParams,
+    ...params,
+  })
+}
+
+export const chromiumIsolatedTab = (params) => {
+  return createRuntimeUsingPlaywright({
+    ...chromiumParams,
+    isolatedTab: true,
+    ...params,
+  })
+}

package/src/runtime_browsers/firefox.js

@@ -0,0 +1,23 @@
+import { createRuntimeUsingPlaywright } from "./using_playwright.js"
+
+const firefoxParams = {
+  browserName: "firefox",
+  // browserVersion will be set by "browser._initializer.version"
+  // see also https://github.com/microsoft/playwright/releases
+  browserVersion: "unset",
+}
+
+export const firefox = (params) => {
+  return createRuntimeUsingPlaywright({
+    ...firefoxParams,
+    ...params,
+  })
+}
+
+export const firefoxIsolatedTab = (params) => {
+  return createRuntimeUsingPlaywright({
+    ...firefoxParams,
+    isolatedTab: true,
+    ...params,
+  })
+}

package/src/runtime_browsers/middleware_istanbul.js

@@ -0,0 +1,65 @@
+import { URL_META } from "@jsenv/url-meta"
+import { applyBabelPlugins } from "@jsenv/ast"
+import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap"
+import { WEB_URL_CONVERTER } from "@jsenv/core/src/helpers/web_url_converter.js"
+
+import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
+
+export const initIstanbulMiddleware = async (
+  page,
+  { webServer, rootDirectoryUrl, coverageConfig },
+) => {
+  const associations = URL_META.resolveAssociations(
+    { cover: coverageConfig },
+    rootDirectoryUrl,
+  )
+  await page.route("**", async (route) => {
+    const request = route.request()
+    const url = request.url() // transform into a local url
+    const fileUrl = WEB_URL_CONVERTER.asFileUrl(url, webServer)
+    const needsInstrumentation = URL_META.applyAssociations({
+      url: fileUrl,
+      associations,
+    }).cover
+    if (!needsInstrumentation) {
+      route.fallback()
+      return
+    }
+    const response = await route.fetch()
+    const originalBody = await response.text()
+    try {
+      const result = await applyBabelPlugins({
+        babelPlugins: [babelPluginInstrument],
+        urlInfo: {
+          originalUrl: fileUrl,
+          // jsenv server could send info to know it's a js module or js classic
+          // but in the end it's not super important
+          // - it's ok to parse js classic as js module considering it's only for istanbul instrumentation
+          type: "js_module",
+          content: originalBody,
+        },
+      })
+      let code = result.code
+      code = SOURCEMAP.writeComment({
+        contentType: "text/javascript",
+        content: code,
+        specifier: generateSourcemapDataUrl(result.map),
+      })
+      route.fulfill({
+        response,
+        body: code,
+        headers: {
+          ...response.headers(),
+          "content-length": Buffer.byteLength(code),
+        },
+      })
+    } catch (e) {
+      if (e.code === "PARSE_ERROR") {
+        route.fulfill({ response })
+      } else {
+        console.error(e)
+        route.fulfill({ response })
+      }
+    }
+  })
+}

package/src/runtime_browsers/middleware_js_supervisor.js

@@ -0,0 +1,98 @@
+import { readFileSync } from "node:fs"
+import { urlToExtension } from "@jsenv/urls"
+import {
+  injectSupervisorIntoHTML,
+  supervisorFileUrl,
+} from "@jsenv/core/src/plugins/supervisor/html_supervisor_injection.js"
+
+export const initJsSupervisorMiddleware = async (
+  page,
+  { webServer, fileUrl, fileServerUrl },
+) => {
+  const inlineScriptContents = new Map()
+
+  const interceptHtmlToExecute = async ({ route }) => {
+    const response = await route.fetch()
+    const originalBody = await response.text()
+    const injectionResult = await injectSupervisorIntoHTML(
+      {
+        content: originalBody,
+        url: fileUrl,
+      },
+      {
+        supervisorScriptSrc: `/@fs/${supervisorFileUrl.slice(
+          "file:///".length,
+        )}`,
+        supervisorOptions: {},
+        inlineAsRemote: true,
+        webServer,
+        onInlineScript: ({ src, textContent }) => {
+          const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href
+          inlineScriptContents.set(inlineScriptWebUrl, textContent)
+        },
+      },
+    )
+    route.fulfill({
+      response,
+      body: injectionResult.content,
+      headers: {
+        ...response.headers(),
+        "content-length": Buffer.byteLength(injectionResult.content),
+      },
+    })
+  }
+
+  const interceptInlineScript = ({ url, route }) => {
+    const inlineScriptContent = inlineScriptContents.get(url)
+    route.fulfill({
+      status: 200,
+      body: inlineScriptContent,
+      headers: {
+        "content-type": "text/javascript",
+        "content-length": Buffer.byteLength(inlineScriptContent),
+      },
+    })
+  }
+
+  const interceptFileSystemUrl = ({ url, route }) => {
+    const relativeUrl = url.slice(webServer.origin.length)
+    const fsPath = relativeUrl.slice("/@fs/".length)
+    const fsUrl = `file:///${fsPath}`
+    const fileContent = readFileSync(new URL(fsUrl), "utf8")
+    route.fulfill({
+      status: 200,
+      body: fileContent,
+      headers: {
+        "content-type": "text/javascript",
+        "content-length": Buffer.byteLength(fileContent),
+      },
+    })
+  }
+
+  await page.route("**", async (route) => {
+    const request = route.request()
+    const url = request.url()
+    if (url === fileServerUrl && urlToExtension(url) === ".html") {
+      interceptHtmlToExecute({
+        url,
+        request,
+        route,
+      })
+      return
+    }
+    if (inlineScriptContents.has(url)) {
+      interceptInlineScript({
+        url,
+        request,
+        route,
+      })
+      return
+    }
+    const fsServerUrl = new URL("/@fs/", webServer.origin)
+    if (url.startsWith(fsServerUrl)) {
+      interceptFileSystemUrl({ url, request, route })
+      return
+    }
+    route.fallback()
+  })
+}