@jsenv/core 23.2.2 → 23.4.2

package/src/launchBrowser.js

@@ -1,12 +1,14 @@
 // https://github.com/microsoft/playwright/blob/master/docs/api.md
 
 import { createDetailedMessage } from "@jsenv/logger"
-
 import {
-  Abortable,
+  Abort,
+  createCallbackListNotifiedOnce,
+  createCallbackList,
   raceProcessTeardownEvents,
-} from "@jsenv/core/src/abort/main.js"
-import { createSignal } from "@jsenv/core/src/signal/signal.js"
+} from "@jsenv/abort"
+import { memoize } from "@jsenv/filesystem"
+
 import { fetchUrl } from "./internal/fetchUrl.js"
 import { validateResponse } from "./internal/response_validation.js"
 import { trackPageToNotify } from "./internal/browser-launcher/trackPageToNotify.js"
@@ -35,7 +37,7 @@ chromiumRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -45,7 +47,9 @@ chromiumRuntime.launch = async ({
   stopOnExit = true,
   share = false,
 }) => {
-  const launchBrowserOperation = Abortable.fromSignal(signal)
+  const launchBrowserOperation = Abort.startOperation()
+  launchBrowserOperation.addAbortSignal(signal)
+
   const sharingToken = share
     ? chromiumSharing.getSharingToken({
         chromiumExecutablePath,
@@ -54,9 +58,7 @@ chromiumRuntime.launch = async ({
         debugPort,
       })
     : chromiumSharing.getUniqueSharingToken()
-
   if (!sharingToken.isUsed()) {
-    Abortable.throwIfAborted(launchBrowserOperation)
     const { chromium } = await import("playwright")
     const launchOperation = launchBrowser("chromium", {
       browserClass: chromium,
@@ -77,10 +79,9 @@ chromiumRuntime.launch = async ({
     sharingToken.setSharedValue(launchOperation)
   }
 
-  const [launchOperation, stopUsingBrowser] = sharingToken.useSharedValue()
-  launchBrowserOperation.cleaner.addCallback(stopUsingBrowser)
-
-  const browser = await launchOperation
+  const [browserPromise, stopUsingBrowser] = sharingToken.useSharedValue()
+  launchBrowserOperation.addEndCallback(stopUsingBrowser)
+  const browser = await browserPromise
 
   if (debug) {
     // https://github.com/puppeteer/puppeteer/blob/v2.0.0/docs/api.md#browserwsendpoint
@@ -105,7 +106,6 @@ chromiumRuntime.launch = async ({
   }
 
   const browserHooks = browserToRuntimeHooks(browser, {
-    launchBrowserOperation,
     browserServerLogLevel,
 
     projectDirectoryUrl,
@@ -115,7 +115,7 @@ chromiumRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable: true,
   })
@@ -151,20 +151,20 @@ firefoxRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
   stopOnExit = true,
   share = false,
 }) => {
-  const launchBrowserOperation = Abortable.fromSignal(signal)
+  const launchBrowserOperation = Abort.startOperation()
+  launchBrowserOperation.addAbortSignal(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,
@@ -179,10 +179,9 @@ firefoxRuntime.launch = async ({
     sharingToken.setSharedValue(launchOperation)
   }
 
-  const [launchOperation, stopUsingBrowser] = sharingToken.useSharedValue()
-  launchBrowserOperation.cleaner.addCallback(stopUsingBrowser)
-
-  const browser = await launchOperation
+  const [browserPromise, stopUsingBrowser] = sharingToken.useSharedValue()
+  launchBrowserOperation.addEndCallback(stopUsingBrowser)
+  const browser = await browserPromise
 
   const browserHooks = browserToRuntimeHooks(browser, {
     launchBrowserOperation,
@@ -195,7 +194,7 @@ firefoxRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
   })
 
@@ -230,20 +229,21 @@ webkitRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
   stopOnExit = true,
   share = false,
 }) => {
-  const launchBrowserOperation = Abortable.fromSignal(signal)
+  const launchBrowserOperation = Abort.startOperation()
+  launchBrowserOperation.addAbortSignal(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,
@@ -257,10 +257,9 @@ webkitRuntime.launch = async ({
     sharingToken.setSharedValue(launchOperation)
   }
 
-  const [launchOperation, stopUsingBrowser] = sharingToken.useSharedValue()
-  launchBrowserOperation.cleaner.addCallback(stopUsingBrowser)
-
-  const browser = await launchOperation
+  const [browserPromise, stopUsingBrowser] = sharingToken.useSharedValue()
+  launchBrowserOperation.addEndCallback(stopUsingBrowser)
+  const browser = await browserPromise
 
   const browserHooks = browserToRuntimeHooks(browser, {
     launchBrowserOperation,
@@ -273,7 +272,7 @@ webkitRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     ignoreErrorHook: (error) => {
       // we catch error during execution but safari throw unhandled rejection
@@ -314,8 +313,8 @@ const launchBrowser = async (
   { launchBrowserOperation, browserClass, options, stopOnExit },
 ) => {
   if (stopOnExit) {
-    Abortable.effect(launchBrowserOperation, (cb) =>
-      raceProcessTeardownEvents(
+    launchBrowserOperation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
         {
           SIGHUP: true,
           SIGTERM: true,
@@ -323,9 +322,9 @@ const launchBrowser = async (
           beforeExit: true,
           exit: true,
         },
-        cb,
-      ),
-    )
+        abort,
+      )
+    })
   }
 
   try {
@@ -337,19 +336,16 @@ const launchBrowser = async (
       handleSIGTERM: false,
       handleSIGHUP: false,
     })
-    launchBrowserOperation.cleaner.addCallback(async () => {
-      await stopBrowser(browser)
-    })
-    if (launchBrowserOperation.signal.aborted) {
-      await launchBrowserOperation.cleaner.clean()
-      Abortable.throwIfAborted(launchBrowserOperation)
-    }
+    launchBrowserOperation.throwIfAborted()
     return browser
   } catch (e) {
     if (launchBrowserOperation.signal.aborted && isTargetClosedError(e)) {
-      return e
+      // rethrow the abort error
+      launchBrowserOperation.throwIfAborted()
     }
     throw e
+  } finally {
+    await launchBrowserOperation.end()
   }
 }
 
@@ -375,8 +371,6 @@ const stopBrowser = async (browser) => {
 const browserToRuntimeHooks = (
   browser,
   {
-    launchBrowserOperation,
-
     projectDirectoryUrl,
     compileServerOrigin,
     outDirectoryRelativeUrl,
@@ -384,33 +378,47 @@ const browserToRuntimeHooks = (
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable = false,
     ignoreErrorHook = () => false,
     transformErrorHook = (error) => error,
   },
 ) => {
-  const stoppedSignal = createSignal({ once: true })
+  const stopCallbackList = createCallbackListNotifiedOnce()
+  const stoppedCallbackList = createCallbackListNotifiedOnce()
+  const stop = memoize(async (reason) => {
+    await stopCallbackList.notify({ reason })
+    stoppedCallbackList.notify({ reason })
+    return { graceful: false }
+  })
+
   // https://github.com/GoogleChrome/puppeteer/blob/v1.4.0/docs/api.md#event-disconnected
-  browser.on("disconnected", stoppedSignal.emit)
+  browser.on("disconnected", () => {
+    stop()
+  })
+
+  stopCallbackList.add(async () => {
+    await stopBrowser(browser)
+  })
 
-  const errorSignal = createSignal()
+  const errorCallbackList = createCallbackList()
 
-  const outputSignal = createSignal()
+  const outputCallbackList = createCallbackList()
 
   const execute = async ({
     signal,
     fileRelativeUrl,
     ignoreHTTPSErrors = true, // we mostly use self signed certificates during tests
   }) => {
-    const executeOperation = Abortable.fromSignal(signal)
-    Abortable.throwIfAborted(executeOperation)
+    const executeOperation = Abort.startOperation()
+    executeOperation.addAbortSignal(signal)
+    executeOperation.throwIfAborted()
     // open a tab to execute to the file
     const browserContext = await browser.newContext({ ignoreHTTPSErrors })
-    Abortable.throwIfAborted(executeOperation)
+    executeOperation.throwIfAborted()
     const page = await browserContext.newPage()
-    launchBrowserOperation.cleaner.addCallback(async () => {
+    executeOperation.addEndCallback(async () => {
       try {
         await browserContext.close()
       } catch (e) {
@@ -425,15 +433,15 @@ const browserToRuntimeHooks = (
       onError: (error) => {
         error = transformErrorHook(error)
         if (!ignoreErrorHook(error)) {
-          errorSignal.emit(error)
+          errorCallbackList.notify(error)
         }
       },
-      onConsole: outputSignal.emit,
+      onConsole: outputCallbackList.notify,
     })
-    launchBrowserOperation.cleaner.addCallback(stopTrackingToNotify)
+    stoppedCallbackList.add(stopTrackingToNotify)
 
     const result = await executeHtmlFile(fileRelativeUrl, {
-      launchBrowserOperation,
+      executeOperation,
 
       projectDirectoryUrl,
       compileServerOrigin,
@@ -443,25 +451,20 @@ const browserToRuntimeHooks = (
       measurePerformance,
       collectPerformance,
       collectCoverage,
-      coverageConfig,
       coverageForceIstanbul,
       coveragePlaywrightAPIAvailable,
+      coverageIgnorePredicate,
       transformErrorHook,
     })
     return result
   }
 
-  Abortable.cleanOnAbort(launchBrowserOperation)
-
   return {
-    stoppedSignal,
-    errorSignal,
-    outputSignal,
+    stoppedCallbackList,
+    errorCallbackList,
+    outputCallbackList,
     execute,
-    stop: async (reason) => {
-      await launchBrowserOperation.cleaner.clean(reason)
-      return { graceful: false }
-    },
+    stop,
   }
 }
 

package/src/launchNode.js

@@ -1,18 +1,9 @@
 import { Script } from "node:vm"
-import cuid from "cuid"
 import { loggerToLogLevel } from "@jsenv/logger"
-import {
-  writeDirectory,
-  resolveUrl,
-  urlToFileSystemPath,
-  removeFileSystemNode,
-  moveDirectoryContent,
-} from "@jsenv/filesystem"
 
 import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
 import { escapeRegexpSpecialCharacters } from "./internal/escapeRegexpSpecialCharacters.js"
 import { createControllableNodeProcess } from "./internal/node-launcher/createControllableNodeProcess.js"
-import { v8CoverageFromNodeV8Directory } from "./internal/executing/coverage/v8CoverageFromNodeV8Directory.js"
 
 export const nodeRuntime = {
   name: "node",
@@ -30,8 +21,8 @@ nodeRuntime.launch = async ({
   measurePerformance,
   collectPerformance,
   collectCoverage = false,
-  coverageConfig,
   coverageForceIstanbul,
+  coverageConfig,
 
   debugPort,
   debugMode,
@@ -69,59 +60,10 @@ nodeRuntime.launch = async ({
     JSENV: true,
   }
 
-  let finalizeExecutionResult
-
-  if (collectCoverage) {
-    // v8 coverage is written in a directoy and auto propagate to subprocesses
-    // through process.env.NODE_V8_COVERAGE.
-
-    if (coverageForceIstanbul) {
-      // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
-      // into the child_process
-      env.NODE_V8_COVERAGE = ""
-    }
-    // } else if (process.env.NODE_V8_COVERAGE) {
-    //   // The V8_COVERAGE was already set by a parent process or command line.
-    //   // It's the caller that is interested into coverage, it's not anymore this script
-    //   // responsability to set process.env.NODE_V8_COVERAGE nor to read
-    //   // coverage files in the v8 directory.
-    // }
-    // In fact it is so that it's possible to go coverageception:
-    // jsenv collect coverage for tests
-    // which are testing that coverage can be collected for tests
-    // this is possible because we overriding the child process NODE_V8_COVERAGE
-    else {
-      const NODE_V8_COVERAGE = await getNodeV8CoverageDir({
-        projectDirectoryUrl,
-      })
-      env.NODE_V8_COVERAGE = NODE_V8_COVERAGE
-
-      // 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
-          }
-
-          const v8Coverage = await v8CoverageFromNodeV8Directory({
-            projectDirectoryUrl,
-            NODE_V8_COVERAGE,
-            coverageConfig,
-          })
-          return v8Coverage
-        }, NODE_V8_COVERAGE)
-        executionResult.coverage = coverage
-        return executionResult
-      }
-    }
+  if (coverageForceIstanbul) {
+    // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
+    // into the child_process
+    env.NODE_V8_COVERAGE = ""
   }
 
   commandLineOptions = [
@@ -132,9 +74,9 @@ nodeRuntime.launch = async ({
   const logLevel = loggerToLogLevel(logger)
   const {
     execArgv,
-    stoppedSignal,
-    errorSignal,
-    outputSignal,
+    stoppedCallbackList,
+    errorCallbackList,
+    outputCallbackList,
     stop,
     requestActionOnChildProcess,
   } = await createControllableNodeProcess({
@@ -193,44 +135,14 @@ nodeRuntime.launch = async ({
       // because process.env is very big
       // env,
     },
-    stoppedSignal,
-    errorSignal,
-    outputSignal,
+    stoppedCallbackList,
+    errorCallbackList,
+    outputCallbackList,
     stop,
     execute,
-    finalizeExecutionResult,
   }
 }
 
-const ensureV8CoverageDirClean = async (fn, NODE_V8_COVERAGE) => {
-  try {
-    return await fn()
-  } finally {
-    if (process.env.NODE_V8_COVERAGE === NODE_V8_COVERAGE) {
-      // do not try to remove or copy coverage
-    } else if (process.env.NODE_V8_COVERAGE) {
-      await moveDirectoryContent({
-        from: NODE_V8_COVERAGE,
-        to: process.env.NODE_V8_COVERAGE,
-      })
-      await removeFileSystemNode(NODE_V8_COVERAGE, {})
-    } else {
-      await removeFileSystemNode(NODE_V8_COVERAGE, {
-        recursive: true,
-      })
-    }
-  }
-}
-
-const getNodeV8CoverageDir = async ({ projectDirectoryUrl }) => {
-  const v8CoverageDirectory = resolveUrl(
-    `./coverage-v8/${cuid()}`,
-    projectDirectoryUrl,
-  )
-  await writeDirectory(v8CoverageDirectory, { allowUseless: true })
-  return urlToFileSystemPath(v8CoverageDirectory)
-}
-
 const transformExecutionResult = (
   executionResult,
   { compileServerOrigin, projectDirectoryUrl },

package/src/startExploring.js

@@ -4,10 +4,6 @@ import {
   urlToRelativeUrl,
 } from "@jsenv/filesystem"
 
-import {
-  Abortable,
-  raceProcessTeardownEvents,
-} from "@jsenv/core/src/abort/main.js"
 import { jsenvCoreDirectoryUrl } from "./internal/jsenvCoreDirectoryUrl.js"
 import {
   assertProjectDirectoryUrl,
@@ -60,18 +56,6 @@ export const startExploring = async ({
   projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
   await assertProjectDirectoryExists({ projectDirectoryUrl })
 
-  const exploringServerOperation = Abortable.fromSignal(signal)
-  if (handleSIGINT) {
-    Abortable.effect(exploringServerOperation, (cb) =>
-      raceProcessTeardownEvents(
-        {
-          SIGINT: true,
-        },
-        cb,
-      ),
-    )
-  }
-
   const outDirectoryRelativeUrl = computeOutDirectoryRelativeUrl({
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
@@ -95,7 +79,8 @@ export const startExploring = async ({
   })
 
   const compileServer = await startCompileServer({
-    signal: exploringServerOperation.signal,
+    signal,
+    handleSIGINT,
     keepProcessAlive,
 
     projectDirectoryUrl,

package/src/abort/abortable.js

@@ -1,172 +0,0 @@
-/*
- * https://github.com/whatwg/dom/issues/920
- */
-
-import { createCleaner } from "./cleaner.js"
-import { raceCallbacks } from "./callback_race.js"
-import { createCallbackList } from "./callback_list.js"
-
-export const Abortable = {
-  throwIfAborted: (operation) => {
-    if (operation.signal.aborted) {
-      const error = new Error(`The operation was aborted`)
-      error.name = "AbortError"
-      error.type = "aborted"
-      throw error
-    }
-  },
-
-  isAbortError: (error) => {
-    return error.name === "AbortError"
-  },
-
-  start: () => {
-    const abortController = new AbortController()
-    const abort = (value) => abortController.abort(value)
-    const signal = abortController.signal
-    const cleaner = createCleaner()
-
-    // abortCallbackList is used to ignore the max listeners warning from Node.js
-    // this warning is useful but becomes problematic when it's expected
-    // (a function doing 20 http call in parallel)
-    // To be 100% sure we don't have memory leak, only Abortable.asyncCallback
-    // uses abortCallbackList to know when something is aborted
-    const abortCallbackList = createCallbackList()
-    signal.onabort = () => {
-      const callbacks = abortCallbackList.copy()
-      abortCallbackList.clear()
-      callbacks.forEach((callback) => {
-        callback()
-      })
-    }
-    cleaner.addCallback(() => {
-      abortCallbackList.clear()
-    })
-
-    const operation = {
-      abort,
-      signal,
-      abortCallbackList,
-      cleaner,
-    }
-
-    return operation
-  },
-
-  fromSignal: (signal) => {
-    const operation = Abortable.start()
-    Abortable.followSignal(operation, signal)
-    return operation
-  },
-
-  followSignal: (operation, signal, cleanup = cleanupNoop) => {
-    if (operation.signal.aborted) {
-      return () => {}
-    }
-
-    if (signal.aborted) {
-      operation.abort()
-      return () => {}
-    }
-
-    return raceCallbacks(
-      {
-        parent_abort: (cb) => {
-          return operation.abortCallbackList.add(cb)
-        },
-        child_abort: (cb) => {
-          return addEventListener(signal, "abort", cb)
-        },
-        cleaned: (cb) => {
-          return operation.cleaner.addCallback(cb)
-        },
-      },
-      (winner) => {
-        const raceEffects = {
-          parent_abort: () => {
-            // Nothing to do, exists to remove
-            // - "abort" event listener on parent
-            // - "abort" event listener on child
-            cleanup()
-          },
-          child_abort: () => {
-            operation.abort()
-          },
-          cleaned: () => {
-            // Nothing to do, exists to remove
-            // - "abort" event listener on parent
-            // - "abort" event listener on child
-            cleanup()
-          },
-        }
-        raceEffects[winner.name](winner.value)
-      },
-    )
-  },
-
-  effect: (operation, effect) => {
-    const abortController = new AbortController()
-    const returnValue = effect((value) => abortController.abort(value))
-    const cleanup =
-      typeof returnValue === "function" ? returnValue : cleanupNoop
-    const signal = abortController.signal
-
-    Abortable.followSignal(operation, signal, cleanup)
-    return {
-      signal,
-      cleanup,
-    }
-  },
-
-  timeout: (operation, ms) => {
-    return Abortable.effect(operation, (abort) => {
-      const timeoutId = setTimeout(abort, ms)
-      return () => {
-        clearTimeout(timeoutId)
-      }
-    })
-  },
-
-  cleanOnAbort: (operation) => {
-    const removeAbortEventListener = addEventListener(
-      operation.signal,
-      "abort",
-      () => {
-        removeAbortEventListener()
-        operation.cleaner.clean("operation aborted")
-      },
-    )
-    return removeAbortEventListener
-  },
-
-  // Provide a signal to the callback
-  // this signal won't inherit the current signal max listeners
-  asyncCallback: async (operation, asyncFunction) => {
-    Abortable.throwIfAborted(operation)
-
-    const abortController = new AbortController()
-    const signal = abortController.signal
-
-    const removeOperationAbortCallback = operation.abortCallbackList.add(() => {
-      abortController.abort()
-    })
-
-    try {
-      const value = await asyncFunction(signal)
-      removeOperationAbortCallback()
-      return value
-    } catch (e) {
-      removeOperationAbortCallback()
-      throw e
-    }
-  },
-}
-
-const cleanupNoop = () => {}
-
-const addEventListener = (target, eventName, cb) => {
-  target.addEventListener(eventName, cb)
-  return () => {
-    target.removeEventListener(eventName, cb)
-  }
-}