@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

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

@@ -1,16 +1,18 @@
 import { Script } from "node:vm"
-import { createDetailedMessage } from "@jsenv/logger"
+
+import { createDetailedMessage } from "@jsenv/log"
 import {
   Abort,
   createCallbackListNotifiedOnce,
   raceProcessTeardownEvents,
+  raceCallbacks,
 } from "@jsenv/abort"
-import { moveUrl } from "@jsenv/filesystem"
+import { moveUrl } from "@jsenv/urls"
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
+import { escapeRegexpSpecialChars } from "@jsenv/utils/src/string/escape_regexp_special_chars.js"
 
-import { memoize } from "@jsenv/utils/memoize/memoize.js"
-import { filterV8Coverage } from "@jsenv/utils/coverage/v8_coverage_from_directory.js"
-import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/utils/coverage/istanbul_coverage_composition.js"
-import { escapeRegexpSpecialChars } from "@jsenv/utils/string/escape_regexp_special_chars.js"
+import { filterV8Coverage } from "@jsenv/core/src/test/coverage/v8_coverage_from_directory.js"
+import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/test/coverage/istanbul_coverage_composition.js"
 
 export const createRuntimeFromPlaywright = ({
   browserName,
@@ -34,7 +36,7 @@ export const createRuntimeFromPlaywright = ({
     server,
 
     // measurePerformance,
-    // collectPerformance,
+    collectPerformance,
     collectCoverage = false,
     coverageForceIstanbul,
     urlShouldBeCovered,
@@ -42,10 +44,7 @@ export const createRuntimeFromPlaywright = ({
     stopAfterAllSignal,
     stopSignal,
     keepRunning,
-    onStop,
-    onError,
     onConsole,
-    onResult,
 
     executablePath,
     headful = false,
@@ -74,11 +73,27 @@ export const createRuntimeFromPlaywright = ({
     }
     const { browser, browserContext } = await browserAndContextPromise
     const closeBrowser = async () => {
+      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 stopBrowser(browser)
+        await browser.close()
       } catch (e) {
-        onError(e)
+        if (isTargetClosedError(e)) {
+          return
+        }
+        throw e
       }
+      await disconnected
     }
     const page = await browserContext.newPage()
     const closePage = async () => {
@@ -88,44 +103,9 @@ export const createRuntimeFromPlaywright = ({
         if (isTargetClosedError(e)) {
           return
         }
-        onError(e)
-      }
-    }
-    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
-    if (isBrowserDedicatedToExecution) {
-      browser.on("disconnected", async () => {
-        await cleanup("browser disconnected")
-        onStop({ reason: "browser disconnected" })
-      })
-      cleanupCallbackList.add(closePage)
-      cleanupCallbackList.add(closeBrowser)
-    } else {
-      const disconnectedCallback = async () => {
-        await cleanup("browser disconnected")
-        onError(new Error("browser disconnected during execution"))
-      }
-      browser.on("disconnected", disconnectedCallback)
-      page.on("close", () => {
-        onStop({ reason: "page closed" })
-      })
-      cleanupCallbackList.add(closePage)
-      const notifyPrevious = stopAfterAllSignal.notify
-      stopAfterAllSignal.notify = async () => {
-        await notifyPrevious()
-        browser.removeListener("disconnected", disconnectedCallback)
-        await closeBrowser()
+        throw e
       }
     }
-    const stopTrackingToNotify = trackPageToNotify(page, {
-      onError: (error) => {
-        error = transformErrorHook(error)
-        if (!ignoreErrorHook(error)) {
-          onError(error)
-        }
-      },
-      onConsole,
-    })
-    cleanupCallbackList.add(stopTrackingToNotify)
 
     let resultTransformer = (result) => result
     if (collectCoverage) {
@@ -169,30 +149,213 @@ export const createRuntimeFromPlaywright = ({
         resultTransformer = composeTransformer(
           resultTransformer,
           async (result) => {
-            result.coverage = generateCoverageForPage(result.namespace)
+            const scriptExecutionResults = result.namespace
+            if (scriptExecutionResults) {
+              result.coverage = generateCoverageForPage(scriptExecutionResults)
+            }
             return result
           },
         )
       }
     } else {
       resultTransformer = composeTransformer(resultTransformer, (result) => {
-        const { namespace: fileExecutionResultMap } = result
-        Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
-          delete fileExecutionResultMap[fileRelativeUrl].coverage
-        })
+        const scriptExecutionResults = result.namespace
+        if (scriptExecutionResults) {
+          Object.keys(scriptExecutionResults).forEach((fileRelativeUrl) => {
+            delete scriptExecutionResults[fileRelativeUrl].coverage
+          })
+        }
         return result
       })
     }
+
+    if (collectPerformance) {
+      resultTransformer = composeTransformer(
+        resultTransformer,
+        async (result) => {
+          const performance = await page.evaluate(
+            /* eslint-disable no-undef */
+            /* istanbul ignore next */
+            () => {
+              const { performance } = window
+              if (!performance) {
+                return null
+              }
+              const measures = {}
+              const measurePerfEntries = performance.getEntriesByType("measure")
+              measurePerfEntries.forEach((measurePerfEntry) => {
+                measures[measurePerfEntry.name] = measurePerfEntry.duration
+              })
+              return {
+                timeOrigin: performance.timeOrigin,
+                timing: performance.timing.toJSON(),
+                navigation: performance.navigation.toJSON(),
+                measures,
+              }
+            },
+            /* eslint-enable no-undef */
+          )
+          result.performance = performance
+          return result
+        },
+      )
+    }
+
     const fileClientUrl = new URL(fileRelativeUrl, `${server.origin}/`).href
-    await page.goto(fileClientUrl, { timeout: 0 })
-    let result = await getResult({
-      page,
-      rootDirectoryUrl,
-      server,
-      transformErrorHook,
+
+    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
+    const removeConsoleListener = registerEvent({
+      object: page,
+      eventType: "console",
+      // https://github.com/microsoft/playwright/blob/master/docs/api.md#event-console
+      callback: async (consoleMessage) => {
+        onConsole({
+          type: consoleMessage.type(),
+          text: `${extractTextFromConsoleMessage(consoleMessage)}
+    `,
+        })
+      },
     })
-    result = await resultTransformer(result)
-    onResult(result)
+    cleanupCallbackList.add(removeConsoleListener)
+    const actionOperation = Abort.startOperation()
+    actionOperation.addAbortSignal(signal)
+    const winnerPromise = new Promise((resolve, reject) => {
+      raceCallbacks(
+        {
+          aborted: (cb) => {
+            return actionOperation.addAbortCallback(cb)
+          },
+          // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
+          error: (cb) => {
+            return registerEvent({
+              object: page,
+              eventType: "error",
+              callback: (error) => {
+                if (ignoreErrorHook(error)) {
+                  return
+                }
+                cb(transformErrorHook(error))
+              },
+            })
+          },
+          // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-pageerror
+          pageerror: (cb) => {
+            return registerEvent({
+              object: page,
+              eventType: "pageerror",
+              callback: (error) => {
+                if (ignoreErrorHook(error)) {
+                  return
+                }
+                cb(transformErrorHook(error))
+              },
+            })
+          },
+          closed: (cb) => {
+            // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
+            if (isBrowserDedicatedToExecution) {
+              browser.on("disconnected", async () => {
+                cb({ reason: "browser disconnected" })
+              })
+              cleanupCallbackList.add(closePage)
+              cleanupCallbackList.add(closeBrowser)
+            } else {
+              const disconnectedCallback = async () => {
+                throw new Error("browser disconnected during execution")
+              }
+              browser.on("disconnected", disconnectedCallback)
+              page.on("close", () => {
+                cb({ reason: "page closed" })
+              })
+              cleanupCallbackList.add(closePage)
+              cleanupCallbackList.add(() => {
+                browser.removeListener("disconnected", disconnectedCallback)
+              })
+              const notifyPrevious = stopAfterAllSignal.notify
+              stopAfterAllSignal.notify = async () => {
+                await notifyPrevious()
+                browser.removeListener("disconnected", disconnectedCallback)
+                await closeBrowser()
+              }
+            }
+          },
+          response: async (cb) => {
+            try {
+              await page.goto(fileClientUrl, { timeout: 0 })
+              const result = await page.evaluate(
+                /* eslint-disable no-undef */
+                /* istanbul ignore next */
+                () => {
+                  if (!window.__html_supervisor__) {
+                    throw new Error(`window.__html_supervisor__ not found`)
+                  }
+                  return window.__html_supervisor__.getScriptExecutionResults()
+                },
+                /* eslint-enable no-undef */
+              )
+              const { status, scriptExecutionResults } = result
+              if (status === "errored") {
+                const { exceptionSource } = result
+                const error = evalException(exceptionSource, {
+                  rootDirectoryUrl,
+                  server,
+                  transformErrorHook,
+                })
+                cb({
+                  status: "errored",
+                  error,
+                  namespace: scriptExecutionResults,
+                })
+              } else {
+                cb({
+                  status: "completed",
+                  namespace: scriptExecutionResults,
+                })
+              }
+            } catch (e) {
+              reject(e)
+            }
+          },
+        },
+        resolve,
+      )
+    })
+
+    const getResult = async () => {
+      const winner = await winnerPromise
+      if (winner.name === "aborted") {
+        return {
+          status: "aborted",
+        }
+      }
+      if (winner.name === "error" || winner.name === "pageerror") {
+        const error = winner.data
+        return {
+          status: "errored",
+          error,
+        }
+      }
+      if (winner.name === "closed") {
+        return {
+          status: "errored",
+          error: isBrowserDedicatedToExecution
+            ? new Error(`browser disconnected during execution`)
+            : new Error(`page closed during execution`),
+        }
+      }
+      return winner.data
+    }
+    let result
+
+    try {
+      result = await getResult()
+      result = await resultTransformer(result)
+    } catch (e) {
+      result = {
+        status: "errored",
+        error: e,
+      }
+    }
     if (keepRunning) {
       stopSignal.notify = cleanup
     } else {
@@ -214,40 +377,6 @@ export const createRuntimeFromPlaywright = ({
   return runtime
 }
 
-const getResult = async ({
-  page,
-  rootDirectoryUrl,
-  server,
-  transformErrorHook,
-}) => {
-  const result = await page.evaluate(
-    /* eslint-disable no-undef */
-    /* istanbul ignore next */
-    () => {
-      return window.__html_supervisor__.getScriptExecutionResults()
-    },
-    /* eslint-enable no-undef */
-  )
-  const { status, scriptExecutionResults } = result
-  if (status === "errored") {
-    const { exceptionSource } = result
-    const error = evalException(exceptionSource, {
-      rootDirectoryUrl,
-      server,
-      transformErrorHook,
-    })
-    return {
-      status: "errored",
-      error,
-      namespace: scriptExecutionResults,
-    }
-  }
-  return {
-    status: "completed",
-    namespace: scriptExecutionResults,
-  }
-}
-
 const generateCoverageForPage = (scriptExecutionResults) => {
   let istanbulCoverageComposed = null
   Object.keys(scriptExecutionResults).forEach((fileRelativeUrl) => {
@@ -262,31 +391,6 @@ const generateCoverageForPage = (scriptExecutionResults) => {
   return istanbulCoverageComposed
 }
 
-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,
@@ -366,39 +470,6 @@ const isTargetClosedError = (error) => {
   return false
 }
 
-const trackPageToNotify = (page, { onError, onConsole }) => {
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-error
-  const removeErrorListener = registerEvent({
-    object: page,
-    eventType: "error",
-    callback: onError,
-  })
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-pageerror
-  const removePageErrorListener = registerEvent({
-    object: page,
-    eventType: "pageerror",
-    callback: onError,
-  })
-  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-console
-  const removeConsoleListener = registerEvent({
-    object: page,
-    eventType: "console",
-    // https://github.com/microsoft/playwright/blob/master/docs/api.md#event-console
-    callback: async (consoleMessage) => {
-      onConsole({
-        type: consoleMessage.type(),
-        text: `${extractTextFromConsoleMessage(consoleMessage)}
-`,
-      })
-    },
-  })
-  return () => {
-    removeErrorListener()
-    removePageErrorListener()
-    removeConsoleListener()
-  }
-}
-
 const composeTransformer = (previousTransformer, transformer) => {
   return async (value) => {
     const transformedValue = await previousTransformer(value)

package/src/execute/runtimes/node/child_exec_options.js

@@ -1,6 +1,6 @@
 import { findFreePort } from "@jsenv/server"
-import { createDetailedMessage } from "@jsenv/logger"
 
+import { createDetailedMessage } from "@jsenv/log"
 import { ExecOptions } from "./exec_options.js"
 
 export const createChildExecOptions = async ({

package/src/execute/runtimes/node/controllable_file.mjs

@@ -1,17 +1,33 @@
 import v8 from "node:v8"
 import { uneval } from "@jsenv/uneval"
+import { startObservingPerformances } from "./node_execution_performance.js"
 
 const ACTIONS_AVAILABLE = {
-  "execute-using-dynamic-import": async ({ fileUrl }) => {
-    const namespace = await import(fileUrl)
-    const namespaceResolved = {}
-    await Promise.all([
-      ...Object.keys(namespace).map(async (key) => {
-        const value = await namespace[key]
-        namespaceResolved[key] = value
-      }),
-    ])
-    return namespaceResolved
+  "execute-using-dynamic-import": async ({ fileUrl, collectPerformance }) => {
+    const getNamespace = async () => {
+      const namespace = await import(fileUrl)
+      const namespaceResolved = {}
+      await Promise.all([
+        ...Object.keys(namespace).map(async (key) => {
+          const value = await namespace[key]
+          namespaceResolved[key] = value
+        }),
+      ])
+      return namespaceResolved
+    }
+    if (collectPerformance) {
+      const getPerformance = startObservingPerformances()
+      const namespace = await getNamespace()
+      const performance = await getPerformance()
+      return {
+        namespace,
+        performance,
+      }
+    }
+    const namespace = await getNamespace()
+    return {
+      namespace,
+    }
   },
   "execute-using-require": async ({ fileUrl }) => {
     const { createRequire } = await import("module")

package/src/execute/runtimes/node/kill_process_tree.js

@@ -1,13 +1,11 @@
-import { createRequire } from "node:module"
-
-const require = createRequire(import.meta.url)
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
 
 // see also https://github.com/sindresorhus/execa/issues/96
 export const killProcessTree = async (
   processId,
   { signal, timeout = 2000 },
 ) => {
-  const pidtree = require("pidtree")
+  const pidtree = requireFromJsenv("pidtree")
 
   let descendantProcessIds
   try {

package/src/execute/runtimes/node/node_execution_performance.js

@@ -0,0 +1,67 @@
+import { PerformanceObserver, performance } from "node:perf_hooks"
+
+export const startObservingPerformances = () => {
+  const measureEntries = []
+  // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html
+  const perfObserver = new PerformanceObserver(
+    (
+      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceobserverentrylist
+      list,
+    ) => {
+      const perfMeasureEntries = list.getEntriesByType("measure")
+      measureEntries.push(...perfMeasureEntries)
+    },
+  )
+  perfObserver.observe({
+    entryTypes: ["measure"],
+  })
+  return async () => {
+    // wait for node to call the performance observer
+    await new Promise((resolve) => {
+      setTimeout(resolve)
+    })
+    performance.clearMarks()
+    perfObserver.disconnect()
+    return {
+      ...readNodePerformance(),
+      measures: measuresFromMeasureEntries(measureEntries),
+    }
+  }
+}
+
+const readNodePerformance = () => {
+  const nodePerformance = {
+    nodeTiming: asPlainObject(performance.nodeTiming),
+    timeOrigin: performance.timeOrigin,
+    eventLoopUtilization: performance.eventLoopUtilization(),
+  }
+  return nodePerformance
+}
+
+// remove getters that cannot be stringified
+const asPlainObject = (objectWithGetters) => {
+  const objectWithoutGetters = {}
+  Object.keys(objectWithGetters).forEach((key) => {
+    objectWithoutGetters[key] = objectWithGetters[key]
+  })
+  return objectWithoutGetters
+}
+
+const measuresFromMeasureEntries = (measureEntries) => {
+  const measures = {}
+  // Sort to ensure measures order is predictable
+  // It seems to be already predictable on Node 16+ but
+  // it's not the case on Node 14.
+  measureEntries.sort((a, b) => {
+    return a.startTime - b.startTime
+  })
+  measureEntries.forEach(
+    (
+      // https://nodejs.org/dist/latest-v16.x/docs/api/perf_hooks.html#perf_hooks_class_performanceentry
+      perfMeasureEntry,
+    ) => {
+      measures[perfMeasureEntry.name] = perfMeasureEntry.duration
+    },
+  )
+  return measures
+}