@jsenv/core 33.0.2 → 34.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "33.0.2",
+  "version": "34.0.1",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -43,7 +43,6 @@
     "eslint": "npx eslint . --ext=.js,.mjs,.cjs,.html",
     "dev": "node --conditions=development ./scripts/dev/dev.mjs",
     "test": "node --conditions=development ./scripts/test/test.mjs",
-    "test:resource_hints": "npm run test -- --only-resource-hints",
     "build": "node --conditions=development ./scripts/build/build.mjs",
     "workspace:test": "npm run test --workspaces --if-present -- --workspace",
     "workspace:versions": "node ./scripts/publish/workspace_versions.mjs",
@@ -67,7 +66,7 @@
     "@c88/v8-coverage": "0.1.1",
     "@financial-times/polyfill-useragent-normaliser": "1.10.2",
     "@jsenv/abort": "4.2.4",
-    "@jsenv/ast": "3.0.3",
+    "@jsenv/ast": "3.0.4",
     "@jsenv/babel-plugins": "1.1.5",
     "@jsenv/filesystem": "4.2.3",
     "@jsenv/importmap": "1.2.1",

package/src/basic_fetch.js

@@ -22,19 +22,29 @@ export const basicFetch = async (
       headers,
     })
     req.on("response", (response) => {
-      req.setTimeout(0)
-      let responseBody = ""
-      response.setEncoding("utf8")
-      response.on("data", (chunk) => {
-        responseBody += chunk
-      })
-      response.on("end", () => {
-        req.destroy()
-        if (response.headers["content-type"] === "application/json") {
-          resolve(JSON.parse(responseBody))
-        } else {
-          resolve(responseBody)
-        }
+      resolve({
+        status: response.statusCode,
+        headers: response.headers,
+        json: () => {
+          req.setTimeout(0)
+          req.destroy()
+          return new Promise((resolve) => {
+            if (response.headers["content-type"] !== "application/json") {
+              console.warn("not json")
+            }
+            let responseBody = ""
+            response.setEncoding("utf8")
+            response.on("data", (chunk) => {
+              responseBody += chunk
+            })
+            response.on("end", () => {
+              resolve(JSON.parse(responseBody))
+            })
+            response.on("error", (e) => {
+              reject(e)
+            })
+          })
+        },
       })
     })
     req.on("error", reject)

package/src/build/start_build_server.js

@@ -108,8 +108,9 @@ export const startBuildServer = async ({
     stopOnExit: false,
     stopOnSIGINT: false,
     stopOnInternalError: false,
-    // the worker should be kept alive by the parent otherwise
-    keepProcessAlive,
+    keepProcessAlive: process.env.IMPORTED_BY_TEST_PLAN
+      ? false
+      : keepProcessAlive,
     logLevel: serverLogLevel,
     startLog: false,
 

package/src/dev/file_service.js

@@ -60,7 +60,7 @@ export const createFileService = ({
 
   const getOrCreateContext = (request) => {
     const { runtimeName, runtimeVersion } = parseUserAgentHeader(
-      request.headers["user-agent"],
+      request.headers["user-agent"] || "",
     )
     const runtimeId = `${runtimeName}@${runtimeVersion}`
     const existingContext = contextCache.get(runtimeId)

package/src/dev/start_dev_server.js

@@ -121,7 +121,9 @@ export const startDevServer = async ({
     stopOnExit: false,
     stopOnSIGINT: handleSIGINT,
     stopOnInternalError: false,
-    keepProcessAlive,
+    keepProcessAlive: process.env.IMPORTED_BY_TEST_PLAN
+      ? false
+      : keepProcessAlive,
     logLevel: serverLogLevel,
     startLog: false,
 
@@ -132,6 +134,11 @@ export const startDevServer = async ({
     port,
     requestWaitingMs: 60_000,
     services: [
+      {
+        injectResponseHeaders: () => {
+          return { "x-server-name": "jsenv_dev_server" }
+        },
+      },
       jsenvServiceCORS({
         accessControlAllowRequestOrigin: true,
         accessControlAllowRequestMethod: true,
@@ -145,7 +152,7 @@ export const startDevServer = async ({
       }),
       {
         handleRequest: (request) => {
-          if (request.pathname === "/__server_params__.json") {
+          if (request.pathname === "/__params__.json") {
             const json = JSON.stringify({
               sourceDirectoryUrl,
             })
@@ -158,10 +165,6 @@ export const startDevServer = async ({
               body: json,
             }
           }
-          if (request.pathname === "/__stop__") {
-            server.stop()
-            return { status: 200 }
-          }
           return null
         },
       },

package/src/execute/execute.js

@@ -14,7 +14,7 @@ import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
 import { createLogger } from "@jsenv/log"
 
-import { pingServer } from "../ping_server.js"
+import { assertAndNormalizeWebServer } from "./web_server_param.js"
 import { run } from "./run.js"
 
 export const execute = async ({
@@ -22,8 +22,7 @@ export const execute = async ({
   handleSIGINT = true,
   logLevel,
   rootDirectoryUrl,
-  sourceDirectoryUrl = rootDirectoryUrl,
-  devServerOrigin,
+  webServer,
 
   fileRelativeUrl,
   allocatedMs,
@@ -57,27 +56,17 @@ export const execute = async ({
     })
   }
 
+  if (runtime.type === "browser") {
+    await assertAndNormalizeWebServer(webServer)
+  }
+
   let resultTransformer = (result) => result
   runtimeParams = {
     rootDirectoryUrl,
-    sourceDirectoryUrl,
-    devServerOrigin,
+    webServer,
     fileRelativeUrl,
     ...runtimeParams,
   }
-  if (runtime.type === "browser") {
-    if (!devServerOrigin) {
-      throw new TypeError(
-        `devServerOrigin is required to execute file on a browser`,
-      )
-    }
-    const devServerStarted = await pingServer(devServerOrigin)
-    if (!devServerStarted) {
-      throw new Error(
-        `no server listening at ${devServerOrigin}. It is required to execute file`,
-      )
-    }
-  }
 
   let result = await run({
     signal: executeOperation.signal,

package/src/execute/runtimes/browsers/from_playwright.js

@@ -1,4 +1,4 @@
-import { writeFileSync } from "node:fs"
+import { readFileSync, writeFileSync } from "node:fs"
 
 import { createDetailedMessage } from "@jsenv/log"
 import {
@@ -7,17 +7,21 @@ import {
   raceProcessTeardownEvents,
   raceCallbacks,
 } from "@jsenv/abort"
-import { moveUrl, urlIsInsideOf } from "@jsenv/urls"
+import { moveUrl, urlIsInsideOf, urlToExtension } from "@jsenv/urls"
 import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
 
 import { filterV8Coverage } from "@jsenv/core/src/test/coverage/v8_coverage.js"
 import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/test/coverage/istanbul_coverage_composition.js"
+import {
+  injectSupervisorIntoHTML,
+  supervisorFileUrl,
+} from "../../../plugins/supervisor/html_supervisor_injection.js"
 
 export const createRuntimeFromPlaywright = ({
   browserName,
   browserVersion,
   coveragePlaywrightAPIAvailable = false,
-  ignoreErrorHook = () => false,
+  shouldIgnoreError = () => false,
   transformErrorHook = (error) => error,
   isolatedTab = false,
 }) => {
@@ -31,9 +35,8 @@ export const createRuntimeFromPlaywright = ({
     signal = new AbortController().signal,
     logger,
     rootDirectoryUrl,
+    webServer,
     fileRelativeUrl,
-    devServerOrigin,
-    sourceDirectoryUrl,
 
     // measurePerformance,
     collectPerformance,
@@ -51,6 +54,20 @@ export const createRuntimeFromPlaywright = ({
     playwrightLaunchOptions = {},
     ignoreHTTPSErrors = true,
   }) => {
+    const fileUrl = new URL(fileRelativeUrl, rootDirectoryUrl).href
+    if (!urlIsInsideOf(fileUrl, webServer.rootDirectoryUrl)) {
+      throw new Error(`Cannot execute file that is outside web server root directory
+--- file --- 
+${fileUrl}
+--- web server root directory url ---
+${webServer.rootDirectoryUrl}`)
+    }
+    const fileServerUrl = moveUrl({
+      url: fileUrl,
+      from: webServer.rootDirectoryUrl,
+      to: `${webServer.origin}/`,
+    })
+
     const cleanupCallbackList = createCallbackListNotifiedOnce()
     const cleanup = memoize(async (reason) => {
       await cleanupCallbackList.notify({ reason })
@@ -112,6 +129,13 @@ export const createRuntimeFromPlaywright = ({
           : {}),
       },
     })
+    if (!webServer.isJsenvDevServer) {
+      await initJsExecutionMiddleware(page, {
+        webServer,
+        fileUrl,
+        fileServerUrl,
+      })
+    }
     const closePage = async () => {
       try {
         await page.close()
@@ -145,8 +169,8 @@ export const createRuntimeFromPlaywright = ({
             (v8CoveragesWithWebUrl) => {
               const fsUrl = moveUrl({
                 url: v8CoveragesWithWebUrl.url,
-                from: `${devServerOrigin}/`,
-                to: sourceDirectoryUrl,
+                from: `${webServer.origin}/`,
+                to: webServer.rootDirectoryUrl,
               })
               return {
                 ...v8CoveragesWithWebUrl,
@@ -218,19 +242,6 @@ export const createRuntimeFromPlaywright = ({
       })
     }
 
-    const fileUrl = new URL(fileRelativeUrl, rootDirectoryUrl).href
-    if (!urlIsInsideOf(fileUrl, sourceDirectoryUrl)) {
-      throw new Error(`Cannot execute file that is outside source directory
---- file --- 
-${fileUrl}
---- source directory ---
-${sourceDirectoryUrl}`)
-    }
-    const fileDevServerUrl = moveUrl({
-      url: fileUrl,
-      from: sourceDirectoryUrl,
-      to: `${devServerOrigin}/`,
-    })
     // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
     const removeConsoleListener = registerEvent({
       object: page,
@@ -247,6 +258,7 @@ ${sourceDirectoryUrl}`)
     cleanupCallbackList.add(removeConsoleListener)
     const actionOperation = Abort.startOperation()
     actionOperation.addAbortSignal(signal)
+
     const winnerPromise = new Promise((resolve, reject) => {
       raceCallbacks(
         {
@@ -259,7 +271,7 @@ ${sourceDirectoryUrl}`)
               object: page,
               eventType: "error",
               callback: (error) => {
-                if (ignoreErrorHook(error)) {
+                if (shouldIgnoreError(error, "error")) {
                   return
                 }
                 cb(transformErrorHook(error))
@@ -272,7 +284,10 @@ ${sourceDirectoryUrl}`)
           //     object: page,
           //     eventType: "pageerror",
           //     callback: (error) => {
-          //       if (ignoreErrorHook(error)) {
+          //       if (
+          //         webServer.isJsenvDevServer ||
+          //         shouldIgnoreError(error, "pageerror")
+          //       ) {
           //         return
           //       }
           //       result.errors.push(transformErrorHook(error))
@@ -312,15 +327,29 @@ ${sourceDirectoryUrl}`)
           },
           response: async (cb) => {
             try {
-              await page.goto(fileDevServerUrl, { timeout: 0 })
+              await page.goto(fileServerUrl, { timeout: 0 })
               const returnValue = await page.evaluate(
                 /* eslint-disable no-undef */
                 /* istanbul ignore next */
-                () => {
+                async () => {
+                  let startTime
+                  try {
+                    startTime = window.performance.timing.navigationStart
+                  } catch (e) {
+                    startTime = Date.now()
+                  }
                   if (!window.__supervisor__) {
-                    throw new Error(`window.__supervisor__ not found`)
+                    throw new Error("window.__supervisor__ is undefined")
+                  }
+                  const executionResultFromJsenvSupervisor =
+                    await window.__supervisor__.getDocumentExecutionResult()
+                  return {
+                    type: "window_supervisor",
+                    startTime,
+                    endTime: Date.now(),
+                    executionResults:
+                      executionResultFromJsenvSupervisor.executionResults,
                   }
-                  return window.__supervisor__.getDocumentExecutionResult()
                 },
                 /* eslint-enable no-undef */
               )
@@ -346,6 +375,12 @@ ${sourceDirectoryUrl}`)
         result.errors.push(error)
         return
       }
+      if (winner.name === "pageerror") {
+        let error = winner.data
+        result.status = "failed"
+        result.errors.push(error)
+        return
+      }
       if (winner.name === "closed") {
         result.status = "failed"
         result.errors.push(
@@ -355,7 +390,7 @@ ${sourceDirectoryUrl}`)
         )
         return
       }
-      // winner.name = 'response'
+      // winner.name === "response"
       const { executionResults } = winner.data
       result.status = "completed"
       result.namespace = executionResults
@@ -363,10 +398,17 @@ ${sourceDirectoryUrl}`)
         const executionResult = executionResults[key]
         if (executionResult.status === "failed") {
           result.status = "failed"
-          result.errors.push({
-            ...executionResult.exception,
-            stack: executionResult.exception.text,
-          })
+          if (executionResult.exception) {
+            result.errors.push({
+              ...executionResult.exception,
+              stack: executionResult.exception.text,
+            })
+          } else {
+            result.errors.push({
+              ...executionResult.error,
+              stack: executionResult.error.stack,
+            })
+          }
         }
       })
     }
@@ -397,7 +439,7 @@ ${sourceDirectoryUrl}`)
       browserName,
       browserVersion,
       coveragePlaywrightAPIAvailable,
-      ignoreErrorHook,
+      shouldIgnoreError,
       transformErrorHook,
       isolatedTab: true,
     })
@@ -528,6 +570,100 @@ const extractTextFromConsoleMessage = (consoleMessage) => {
   //   return text
 }
 
+const initJsExecutionMiddleware = async (
+  page,
+  { webServer, fileUrl, fileServerUrl },
+) => {
+  const inlineScriptContents = new Map()
+
+  const interceptHtmlToExecute = async ({ route }) => {
+    // Fetch original response.
+    const response = await route.fetch()
+    // Add a prefix to the title.
+    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()
+  })
+}
+
 const registerEvent = ({ object, eventType, callback }) => {
   object.on(eventType, callback)
   return () => {

package/src/execute/runtimes/browsers/webkit.js

@@ -5,7 +5,7 @@ export const webkit = createRuntimeFromPlaywright({
   // browserVersion will be set by "browser._initializer.version"
   // see also https://github.com/microsoft/playwright/releases
   browserVersion: "unset",
-  ignoreErrorHook: (error) => {
+  shouldIgnoreError: (error) => {
     // we catch error during execution but safari throw unhandled rejection
     // in a non-deterministic way.
     // I suppose it's due to some race condition to decide if the promise is catched or not

package/src/execute/web_server_param.js

@@ -0,0 +1,68 @@
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
+
+import { pingServer } from "../ping_server.js"
+import { basicFetch } from "../basic_fetch.js"
+
+export const assertAndNormalizeWebServer = async (webServer) => {
+  if (!webServer) {
+    throw new TypeError(
+      `webServer is required when running tests on browser(s)`,
+    )
+  }
+  const unexpectedParamNames = Object.keys(webServer).filter((key) => {
+    return !["origin", "moduleUrl", "rootDirectoryUrl"].includes(key)
+  })
+  if (unexpectedParamNames.length > 0) {
+    throw new TypeError(
+      `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
+    )
+  }
+
+  let aServerIsListening = await pingServer(webServer.origin)
+  if (!aServerIsListening) {
+    if (!webServer.moduleUrl) {
+      throw new TypeError(
+        `webServer.moduleUrl is required as there is no server listening "${webServer.origin}"`,
+      )
+    }
+    try {
+      process.env.IMPORTED_BY_TEST_PLAN = "1"
+      await import(webServer.moduleUrl)
+      delete process.env.IMPORTED_BY_TEST_PLAN
+    } catch (e) {
+      if (e.code === "ERR_MODULE_NOT_FOUND") {
+        throw new Error(
+          `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
+        )
+      }
+      throw e
+    }
+    aServerIsListening = await pingServer(webServer.origin)
+    if (!aServerIsListening) {
+      throw new Error(
+        `webServer.moduleUrl did not start a server listening at "${webServer.origin}", check file at "${webServer.moduleUrl}"`,
+      )
+    }
+  }
+  const { headers } = await basicFetch(webServer.origin)
+  if (headers["x-server-name"] === "jsenv_dev_server") {
+    webServer.isJsenvDevServer = true
+    const { json } = await basicFetch(`${webServer.origin}/__params__.json`, {
+      rejectUnauthorized: false,
+    })
+    if (webServer.rootDirectoryUrl === undefined) {
+      const jsenvDevServerParams = await json()
+      webServer.rootDirectoryUrl = jsenvDevServerParams.sourceDirectoryUrl
+    } else {
+      webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
+        webServer.rootDirectoryUrl,
+        "webServer.rootDirectoryUrl",
+      )
+    }
+  } else {
+    webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
+      webServer.rootDirectoryUrl,
+      "webServer.rootDirectoryUrl",
+    )
+  }
+}

package/src/kitchen/compat/features_compatibility.js

@@ -31,6 +31,8 @@ export const featuresCompatMap = {
   },
   import_meta_resolve: {
     chrome: "107",
+    edge: "105",
+    firefox: "106",
   },
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import#browser_compatibility
   import_dynamic: {
@@ -61,6 +63,7 @@ export const featuresCompatMap = {
     opera: "76",
     samsung: "15",
     firefox: "108",
+    safari: "16.4",
   },
   import_type_json: {
     chrome: "91",

package/src/plugins/autoreload/client/reload.js

@@ -67,10 +67,7 @@ export const getDOMNodesUsingUrl = (urlToReload) => {
         nodes.push({
           node: script,
           reload: () =>
-            window.__supervisor__.reloadSupervisedScript({
-              type: script.type,
-              src: inlinedFromSrc,
-            }),
+            window.__supervisor__.reloadSupervisedScript(inlinedFromSrc),
         })
       }
     }

package/src/plugins/inline/jsenv_plugin_html_inline_content.js

@@ -1,3 +1,9 @@
+/*
+ * This plugin ensure content inlined inside HTML is cooked (inline <script> for instance)
+ * For <script hot-accept> the script content will be moved to a virtual file
+ * to enable hot reloading
+ */
+
 import { generateInlineContentUrl } from "@jsenv/urls"
 import {
   parseHtmlString,
@@ -8,6 +14,7 @@ import {
   analyzeScriptNode,
   setHtmlNodeAttributes,
   setHtmlNodeText,
+  removeHtmlNodeText,
   getHtmlNodeAttribute,
 } from "@jsenv/ast"
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
@@ -113,16 +120,9 @@ ${e.traceMessage}`)
             ) {
               return
             }
-            if (
-              getHtmlNodeAttribute(scriptNode, "jsenv-cooked-by") ===
-                "jsenv:supervisor" ||
-              getHtmlNodeAttribute(scriptNode, "jsenv-inlined-by") ===
-                "jsenv:supervisor" ||
-              getHtmlNodeAttribute(scriptNode, "jsenv-injected-by") ===
-                "jsenv:supervisor"
-            ) {
-              return
-            }
+
+            const hotAccept =
+              getHtmlNodeAttribute(scriptNode, "hot-accept") !== undefined
             const { type, contentType, extension } =
               analyzeScriptNode(scriptNode)
             const { line, column, lineEnd, columnEnd, isOriginal } =
@@ -161,14 +161,26 @@ ${e.traceMessage}`)
                 inlineContentUrlInfo: inlineScriptUrlInfo,
                 inlineContentReference: inlineScriptReference,
               })
-            })
-            mutations.push(() => {
-              setHtmlNodeText(scriptNode, inlineScriptUrlInfo.content)
-              setHtmlNodeAttributes(scriptNode, {
-                "jsenv-cooked-by": "jsenv:html_inline_content",
-                ...(extension
-                  ? { type: type === "js_module" ? "module" : undefined }
-                  : {}),
+              mutations.push(() => {
+                const attributes = {
+                  "jsenv-cooked-by": "jsenv:html_inline_content",
+                  // 1. <script type="jsx"> becomes <script>
+                  // 2. <script type="module/jsx"> becomes <script type="module">
+                  ...(extension
+                    ? { type: type === "js_module" ? "module" : undefined }
+                    : {}),
+                }
+                if (hotAccept) {
+                  removeHtmlNodeText(scriptNode)
+                  setHtmlNodeAttributes(scriptNode, {
+                    ...attributes,
+                  })
+                } else {
+                  setHtmlNodeText(scriptNode, inlineScriptUrlInfo.content)
+                  setHtmlNodeAttributes(scriptNode, {
+                    ...attributes,
+                  })
+                }
               })
             })
           },