@jsenv/core 23.1.3 → 23.2.2

package/src/launchBrowser.js

@@ -1,14 +1,12 @@
-/* eslint-disable import/max-dependencies */
 // https://github.com/microsoft/playwright/blob/master/docs/api.md
 
-import {
-  createCancellationToken,
-  createStoppableOperation,
-} from "@jsenv/cancellation"
 import { createDetailedMessage } from "@jsenv/logger"
-import { teardownSignal } from "@jsenv/node-signals"
 
-import { trackRessources } from "./internal/trackRessources.js"
+import {
+  Abortable,
+  raceProcessTeardownEvents,
+} from "@jsenv/core/src/abort/main.js"
+import { createSignal } from "@jsenv/core/src/signal/signal.js"
 import { fetchUrl } from "./internal/fetchUrl.js"
 import { validateResponse } from "./internal/response_validation.js"
 import { trackPageToNotify } from "./internal/browser-launcher/trackPageToNotify.js"
@@ -26,8 +24,8 @@ export const chromiumRuntime = {
   version: PLAYWRIGHT_CHROMIUM_VERSION,
 }
 chromiumRuntime.launch = async ({
+  signal = new AbortController().signal,
   browserServerLogLevel,
-  cancellationToken = createCancellationToken(),
   chromiumExecutablePath,
 
   projectDirectoryUrl,
@@ -47,7 +45,7 @@ chromiumRuntime.launch = async ({
   stopOnExit = true,
   share = false,
 }) => {
-  const ressourceTracker = trackRessources()
+  const launchBrowserOperation = Abortable.fromSignal(signal)
   const sharingToken = share
     ? chromiumSharing.getSharingToken({
         chromiumExecutablePath,
@@ -58,12 +56,11 @@ chromiumRuntime.launch = async ({
     : chromiumSharing.getUniqueSharingToken()
 
   if (!sharingToken.isUsed()) {
+    Abortable.throwIfAborted(launchBrowserOperation)
     const { chromium } = await import("playwright")
-
     const launchOperation = launchBrowser("chromium", {
       browserClass: chromium,
-      cancellationToken,
-      ressourceTracker,
+      launchBrowserOperation,
       options: {
         headless,
         executablePath: chromiumExecutablePath,
@@ -81,7 +78,7 @@ chromiumRuntime.launch = async ({
   }
 
   const [launchOperation, stopUsingBrowser] = sharingToken.useSharedValue()
-  ressourceTracker.registerCleanupCallback(stopUsingBrowser)
+  launchBrowserOperation.cleaner.addCallback(stopUsingBrowser)
 
   const browser = await launchOperation
 
@@ -92,7 +89,7 @@ chromiumRuntime.launch = async ({
     const webSocketUrl = new URL(webSocketEndpoint)
     const browserEndpoint = `http://${webSocketUrl.host}/json/version`
     const browserResponse = await fetchUrl(browserEndpoint, {
-      cancellationToken,
+      signal,
       ignoreHttpsError: true,
     })
     const { isValid, message, details } = await validateResponse(
@@ -108,9 +105,8 @@ chromiumRuntime.launch = async ({
   }
 
   const browserHooks = browserToRuntimeHooks(browser, {
+    launchBrowserOperation,
     browserServerLogLevel,
-    cancellationToken,
-    ressourceTracker,
 
     projectDirectoryUrl,
     compileServerOrigin,
@@ -144,7 +140,7 @@ export const firefoxRuntime = {
   version: PLAYWRIGHT_FIREFOX_VERSION,
 }
 firefoxRuntime.launch = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
   firefoxExecutablePath,
   browserServerLogLevel,
 
@@ -162,17 +158,18 @@ firefoxRuntime.launch = async ({
   stopOnExit = true,
   share = false,
 }) => {
-  const ressourceTracker = trackRessources()
+  const launchBrowserOperation = Abortable.fromSignal(signal)
   const sharingToken = share
     ? firefoxSharing.getSharingToken({ firefoxExecutablePath, headless })
     : firefoxSharing.getUniqueSharingToken()
 
   if (!sharingToken.isUsed()) {
+    Abortable.throwIfAborted(launchBrowserOperation)
     const { firefox } = await import("playwright")
     const launchOperation = launchBrowser("firefox", {
       browserClass: firefox,
-      cancellationToken,
-      ressourceTracker,
+
+      launchBrowserOperation,
       options: {
         headless,
         executablePath: firefoxExecutablePath,
@@ -183,14 +180,13 @@ firefoxRuntime.launch = async ({
   }
 
   const [launchOperation, stopUsingBrowser] = sharingToken.useSharedValue()
-  ressourceTracker.registerCleanupCallback(stopUsingBrowser)
+  launchBrowserOperation.cleaner.addCallback(stopUsingBrowser)
 
   const browser = await launchOperation
 
   const browserHooks = browserToRuntimeHooks(browser, {
+    launchBrowserOperation,
     browserServerLogLevel,
-    cancellationToken,
-    ressourceTracker,
 
     projectDirectoryUrl,
     compileServerOrigin,
@@ -223,8 +219,8 @@ export const webkitRuntime = {
   version: PLAYWRIGHT_WEBKIT_VERSION,
 }
 webkitRuntime.launch = async ({
+  signal = new AbortController().signal,
   browserServerLogLevel,
-  cancellationToken = createCancellationToken(),
   webkitExecutablePath,
 
   projectDirectoryUrl,
@@ -241,17 +237,17 @@ webkitRuntime.launch = async ({
   stopOnExit = true,
   share = false,
 }) => {
-  const ressourceTracker = trackRessources()
+  const launchBrowserOperation = Abortable.fromSignal(signal)
   const sharingToken = share
     ? webkitSharing.getSharingToken({ webkitExecutablePath, headless })
     : webkitSharing.getUniqueSharingToken()
 
   if (!sharingToken.isUsed()) {
+    Abortable.throwIfAborted(launchBrowserOperation)
     const { webkit } = await import("playwright")
     const launchOperation = launchBrowser("webkit", {
       browserClass: webkit,
-      cancellationToken,
-      ressourceTracker,
+      launchBrowserOperation,
       options: {
         headless,
         executablePath: webkitExecutablePath,
@@ -262,14 +258,13 @@ webkitRuntime.launch = async ({
   }
 
   const [launchOperation, stopUsingBrowser] = sharingToken.useSharedValue()
-  ressourceTracker.registerCleanupCallback(stopUsingBrowser)
+  launchBrowserOperation.cleaner.addCallback(stopUsingBrowser)
 
   const browser = await launchOperation
 
   const browserHooks = browserToRuntimeHooks(browser, {
+    launchBrowserOperation,
     browserServerLogLevel,
-    cancellationToken,
-    ressourceTracker,
 
     projectDirectoryUrl,
     compileServerOrigin,
@@ -280,6 +275,24 @@ webkitRuntime.launch = async ({
     collectCoverage,
     coverageConfig,
     coverageForceIstanbul,
+    ignoreErrorHook: (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
+      // for now we'll ignore unhandled rejection on wekbkit
+      if (error.name === "Unhandled Promise Rejection") {
+        return true
+      }
+      return false
+    },
+    transformErrorHook: (error) => {
+      // Force error stack to contain the error message
+      // because it's not the case on webkit
+      error.stack = `${error.message}
+  at ${error.stack}`
+
+      return error
+    },
   })
 
   return {
@@ -298,68 +311,71 @@ export const webkitTabRuntime = {
 
 const launchBrowser = async (
   browserName,
-  { cancellationToken, browserClass, ressourceTracker, options, stopOnExit },
+  { launchBrowserOperation, browserClass, options, stopOnExit },
 ) => {
-  const launchOperation = createStoppableOperation({
-    cancellationToken,
-    start: async () => {
-      if (stopOnExit) {
-        const unregisterProcessTeardown = teardownSignal.addCallback(
-          (reason) => {
-            unregisterProcessTeardown()
-            launchOperation.stop(`process ${reason}`)
-          },
-        )
-        ressourceTracker.registerCleanupCallback(unregisterProcessTeardown)
-        cancellationToken.register(unregisterProcessTeardown)
-      }
+  if (stopOnExit) {
+    Abortable.effect(launchBrowserOperation, (cb) =>
+      raceProcessTeardownEvents(
+        {
+          SIGHUP: true,
+          SIGTERM: true,
+          SIGINT: true,
+          beforeExit: true,
+          exit: true,
+        },
+        cb,
+      ),
+    )
+  }
 
-      try {
-        const browser = await browserClass.launch({
-          ...options,
-          // let's handle them to close properly browser + remove listener
-          // instead of relying on playwright to do so
-          handleSIGINT: false,
-          handleSIGTERM: false,
-          handleSIGHUP: false,
-        })
-        return browser
-      } catch (e) {
-        if (cancellationToken.cancellationRequested && isTargetClosedError(e)) {
-          return e
+  try {
+    const browser = await browserClass.launch({
+      ...options,
+      // 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.cleaner.addCallback(async () => {
+      await stopBrowser(browser)
+    })
+    if (launchBrowserOperation.signal.aborted) {
+      await launchBrowserOperation.cleaner.clean()
+      Abortable.throwIfAborted(launchBrowserOperation)
+    }
+    return browser
+  } catch (e) {
+    if (launchBrowserOperation.signal.aborted && isTargetClosedError(e)) {
+      return e
+    }
+    throw e
+  }
+}
+
+const stopBrowser = async (browser) => {
+  const disconnected = browser.isConnected()
+    ? new Promise((resolve) => {
+        const disconnectedCallback = () => {
+          browser.removeListener("disconnected", disconnectedCallback)
+          resolve()
         }
-        throw e
-      }
-    },
-    stop: 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))
-
-      await browser.close()
-      await disconnected
-    },
-  })
-  ressourceTracker.registerCleanupCallback(launchOperation.stop)
+        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))
 
-  return launchOperation
+  await browser.close()
+  await disconnected
 }
 
 const browserToRuntimeHooks = (
   browser,
   {
-    cancellationToken,
-    ressourceTracker,
+    launchBrowserOperation,
 
     projectDirectoryUrl,
     compileServerOrigin,
@@ -371,38 +387,30 @@ const browserToRuntimeHooks = (
     coverageConfig,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable = false,
+    ignoreErrorHook = () => false,
+    transformErrorHook = (error) => error,
   },
 ) => {
-  const disconnected = new Promise((resolve) => {
-    // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
-    browser.on("disconnected", resolve)
-  })
+  const stoppedSignal = createSignal({ once: true })
+  // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
+  browser.on("disconnected", stoppedSignal.emit)
 
-  const errorCallbackArray = []
-  const registerErrorCallback = (callback) => {
-    errorCallbackArray.push(callback)
-    return () => {
-      const index = errorCallbackArray.indexOf(callback)
-      if (index > -1) {
-        errorCallbackArray.splice(index, 1)
-      }
-    }
-  }
+  const errorSignal = createSignal()
 
-  const consoleCallbackArray = []
-  const registerConsoleCallback = (callback) => {
-    consoleCallbackArray.push(callback)
-  }
+  const outputSignal = createSignal()
 
   const execute = async ({
+    signal,
     fileRelativeUrl,
-    // because we use a self signed certificate
-    ignoreHTTPSErrors = true,
+    ignoreHTTPSErrors = true, // we mostly use self signed certificates during tests
   }) => {
+    const executeOperation = Abortable.fromSignal(signal)
+    Abortable.throwIfAborted(executeOperation)
     // open a tab to execute to the file
     const browserContext = await browser.newContext({ ignoreHTTPSErrors })
+    Abortable.throwIfAborted(executeOperation)
     const page = await browserContext.newPage()
-    ressourceTracker.registerCleanupCallback(async () => {
+    launchBrowserOperation.cleaner.addCallback(async () => {
       try {
         await browserContext.close()
       } catch (e) {
@@ -415,19 +423,17 @@ const browserToRuntimeHooks = (
     // track tab error and console
     const stopTrackingToNotify = trackPageToNotify(page, {
       onError: (error) => {
-        errorCallbackArray.forEach((callback) => {
-          callback(error)
-        })
-      },
-      onConsole: ({ type, text }) => {
-        consoleCallbackArray.forEach((callback) => {
-          callback({ type, text })
-        })
+        error = transformErrorHook(error)
+        if (!ignoreErrorHook(error)) {
+          errorSignal.emit(error)
+        }
       },
+      onConsole: outputSignal.emit,
     })
-    ressourceTracker.registerCleanupCallback(stopTrackingToNotify)
-    return executeHtmlFile(fileRelativeUrl, {
-      cancellationToken,
+    launchBrowserOperation.cleaner.addCallback(stopTrackingToNotify)
+
+    const result = await executeHtmlFile(fileRelativeUrl, {
+      launchBrowserOperation,
 
       projectDirectoryUrl,
       compileServerOrigin,
@@ -440,24 +446,22 @@ const browserToRuntimeHooks = (
       coverageConfig,
       coverageForceIstanbul,
       coveragePlaywrightAPIAvailable,
+      transformErrorHook,
     })
+    return result
   }
 
+  Abortable.cleanOnAbort(launchBrowserOperation)
+
   return {
+    stoppedSignal,
+    errorSignal,
+    outputSignal,
+    execute,
     stop: async (reason) => {
-      let unregisterErrorCallback
-      await Promise.race([
-        new Promise((resolve, reject) => {
-          unregisterErrorCallback = registerErrorCallback(reject)
-        }),
-        ressourceTracker.cleanup(reason),
-      ])
-      unregisterErrorCallback()
+      await launchBrowserOperation.cleaner.clean(reason)
+      return { graceful: false }
     },
-    disconnected,
-    registerErrorCallback,
-    registerConsoleCallback,
-    execute,
   }
 }
 

package/src/launchNode.js

@@ -1,8 +1,6 @@
-/* eslint-disable import/max-dependencies */
 import { Script } from "node:vm"
 import cuid from "cuid"
 import { loggerToLogLevel } from "@jsenv/logger"
-import { createCancellationToken } from "@jsenv/cancellation"
 import {
   writeDirectory,
   resolveUrl,
@@ -21,9 +19,9 @@ export const nodeRuntime = {
   version: process.version.slice(1),
 }
 nodeRuntime.launch = async ({
+  signal = new AbortController().signal,
   logger,
   logProcessCommand,
-  cancellationToken = createCancellationToken(),
 
   projectDirectoryUrl,
   compileServerOrigin,
@@ -100,15 +98,19 @@ nodeRuntime.launch = async ({
 
       // the v8 coverage directory is available once the child process is disconnected
       finalizeExecutionResult = async (executionResult) => {
+        if (
+          executionResult.status === "timedout" ||
+          executionResult.status === "aborted"
+        ) {
+          return executionResult
+        }
+
         const coverage = await ensureV8CoverageDirClean(async () => {
           // prefer istanbul if available
           if (executionResult.coverage) {
             return executionResult.coverage
           }
 
-          // give Node.js more time to write the v8 coverage
-          await new Promise((resolve) => setTimeout(resolve, 50))
-
           const v8Coverage = await v8CoverageFromNodeV8Directory({
             projectDirectoryUrl,
             NODE_V8_COVERAGE,
@@ -128,8 +130,15 @@ nodeRuntime.launch = async ({
   ]
 
   const logLevel = loggerToLogLevel(logger)
-  const controllableNodeProcess = await createControllableNodeProcess({
-    cancellationToken,
+  const {
+    execArgv,
+    stoppedSignal,
+    errorSignal,
+    outputSignal,
+    stop,
+    requestActionOnChildProcess,
+  } = await createControllableNodeProcess({
+    signal,
     logLevel,
     debugPort,
     debugMode,
@@ -143,7 +152,7 @@ nodeRuntime.launch = async ({
     logProcessCommand,
   })
 
-  const execute = async ({ fileRelativeUrl, executionId }) => {
+  const execute = async ({ signal, fileRelativeUrl, executionId }) => {
     const executeParams = {
       projectDirectoryUrl,
       compileServerOrigin,
@@ -163,11 +172,11 @@ nodeRuntime.launch = async ({
       remap,
     }
 
-    let executionResult =
-      await controllableNodeProcess.requestActionOnChildProcess({
-        actionType: "execute-using-dynamic-import-fallback-on-systemjs",
-        actionParams: executeParams,
-      })
+    let executionResult = await requestActionOnChildProcess({
+      signal,
+      actionType: "execute-using-dynamic-import-fallback-on-systemjs",
+      actionParams: executeParams,
+    })
 
     executionResult = transformExecutionResult(executionResult, {
       compileServerOrigin,
@@ -178,13 +187,16 @@ nodeRuntime.launch = async ({
   }
 
   return {
-    ...controllableNodeProcess,
     options: {
-      execArgv: controllableNodeProcess.execArgv,
+      execArgv,
       // for now do not pass env, it make debug logs to verbose
       // because process.env is very big
       // env,
     },
+    stoppedSignal,
+    errorSignal,
+    outputSignal,
+    stop,
     execute,
     finalizeExecutionResult,
   }
@@ -201,7 +213,7 @@ const ensureV8CoverageDirClean = async (fn, NODE_V8_COVERAGE) => {
         from: NODE_V8_COVERAGE,
         to: process.env.NODE_V8_COVERAGE,
       })
-      await removeFileSystemNode(NODE_V8_COVERAGE)
+      await removeFileSystemNode(NODE_V8_COVERAGE, {})
     } else {
       await removeFileSystemNode(NODE_V8_COVERAGE, {
         recursive: true,

package/src/playwright_browser_versions.js

@@ -1,5 +1,5 @@
-export const PLAYWRIGHT_CHROMIUM_VERSION = "94.0.4595.0"
+export const PLAYWRIGHT_CHROMIUM_VERSION = "97.0.4666.0"
 
-export const PLAYWRIGHT_FIREFOX_VERSION = "91.0"
+export const PLAYWRIGHT_FIREFOX_VERSION = "93.0"
 
-export const PLAYWRIGHT_WEBKIT_VERSION = "15.0"
+export const PLAYWRIGHT_WEBKIT_VERSION = "15.4"

package/src/requireUsingChildProcess.js

@@ -36,10 +36,11 @@ export const requireUsingChildProcess = async (
 
         return {
           ...controllableNodeProcess,
-          execute: async () => {
+          execute: async ({ signal }) => {
             try {
               const namespace =
                 await controllableNodeProcess.requestActionOnChildProcess({
+                  signal,
                   actionType: "execute-using-require",
                   actionParams: { fileUrl },
                 })

package/src/signal/signal.js

@@ -0,0 +1,65 @@
+export const createSignal = ({ once = false } = {}) => {
+  let callbacks = []
+
+  const signal = {}
+
+  const addCallback = (callback) => {
+    if (typeof callback !== "function") {
+      throw new Error(`callback must be a function, got ${callback}`)
+    }
+
+    // don't register twice
+    const existingCallback = callbacks.find((callbackCandidate) => {
+      return callbackCandidate === callback
+    })
+    if (existingCallback) {
+      if (typeof process.emitWarning === "object") {
+        process.emitWarning(`Trying to register same callback twice`, {
+          CODE: "CALLBACK_DUPLICATION",
+          detail: `It's often the sign that code is executd more than once`,
+        })
+      } else {
+        console.warn(`Trying to add same callback twice`)
+      }
+    } else {
+      callbacks = [...callbacks, callback]
+    }
+
+    return () => {
+      callbacks = arrayWithout(callbacks, callback)
+    }
+  }
+
+  const emit = (value) => {
+    signal.emitted = true
+
+    const callbacksCopy = callbacks.slice()
+    if (once) {
+      callbacks.length = 0
+    }
+    callbacksCopy.forEach((callback) => {
+      callback(value)
+    })
+  }
+
+  signal.emitted = false
+  signal.addCallback = addCallback
+  signal.emit = emit
+
+  return signal
+}
+
+const arrayWithout = (array, item) => {
+  if (array.length === 0) return array
+  const arrayWithoutItem = []
+  let i = 0
+  while (i < array.length) {
+    const value = array[i]
+    i++
+    if (value === item) {
+      continue
+    }
+    arrayWithoutItem.push(value)
+  }
+  return arrayWithoutItem
+}