@jsenv/core 23.2.2 → 23.3.0

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"
@@ -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,
@@ -158,13 +158,13 @@ firefoxRuntime.launch = async ({
   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,
@@ -237,13 +236,14 @@ webkitRuntime.launch = async ({
   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,
@@ -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,
@@ -391,26 +385,40 @@ const browserToRuntimeHooks = (
     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,
@@ -451,17 +459,12 @@ const browserToRuntimeHooks = (
     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

@@ -132,9 +132,9 @@ nodeRuntime.launch = async ({
   const logLevel = loggerToLogLevel(logger)
   const {
     execArgv,
-    stoppedSignal,
-    errorSignal,
-    outputSignal,
+    stoppedCallbackList,
+    errorCallbackList,
+    outputCallbackList,
     stop,
     requestActionOnChildProcess,
   } = await createControllableNodeProcess({
@@ -193,9 +193,9 @@ nodeRuntime.launch = async ({
       // because process.env is very big
       // env,
     },
-    stoppedSignal,
-    errorSignal,
-    outputSignal,
+    stoppedCallbackList,
+    errorCallbackList,
+    outputCallbackList,
     stop,
     execute,
     finalizeExecutionResult,

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)
-  }
-}

package/src/abort/callback_list.js

@@ -1,64 +0,0 @@
-export const createCallbackList = () => {
-  let callbacks = []
-
-  const add = (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 () => {
-      remove(callback)
-    }
-  }
-
-  const remove = (callback) => {
-    callbacks = arrayWithout(callbacks, callback)
-  }
-
-  const clear = () => {
-    callbacks = []
-  }
-
-  const copy = () => {
-    return callbacks.slice()
-  }
-
-  return {
-    add,
-    remove,
-    clear,
-    copy,
-  }
-}
-
-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
-}

package/src/abort/callback_race.js

@@ -1,34 +0,0 @@
-/*
- * See callback_race.md
- */
-
-export const raceCallbacks = (raceDescription, winnerCallback) => {
-  const cleanCallbacks = []
-  let done = false
-
-  const cleanup = () => {
-    const cleanCallbacksCopy = cleanCallbacks.slice()
-    cleanCallbacks.length = 0
-    cleanCallbacksCopy.forEach((clean) => {
-      clean()
-    })
-  }
-
-  Object.keys(raceDescription).forEach((candidateName) => {
-    const register = raceDescription[candidateName]
-    const returnValue = register((data) => {
-      if (done) return
-      done = true
-      cleanup()
-      winnerCallback({
-        name: candidateName,
-        data,
-      })
-    })
-    if (typeof returnValue === "function") {
-      cleanCallbacks.push(returnValue)
-    }
-  })
-
-  return cleanup
-}

package/src/abort/cleaner.js

@@ -1,22 +0,0 @@
-import { createCallbackList } from "./callback_list.js"
-
-export const createCleaner = () => {
-  const callbackList = createCallbackList()
-
-  const addCallback = (callback) => {
-    return callbackList.add(callback)
-  }
-
-  const clean = async (reason) => {
-    const callbacks = callbackList.copy()
-    callbackList.clear()
-
-    await Promise.all(
-      callbacks.map(async (callback) => {
-        await callback(reason)
-      }),
-    )
-  }
-
-  return { addCallback, clean }
-}

package/src/abort/main.js

@@ -1,32 +0,0 @@
-/*
- * When starting an http server there is two distinct things
- * that code may want to do:
- * 1. Abort the server while it's starting
- * 2. Stop server onces its started
- *
- * This can be achieved with the following code where
- * server is aborted if it takes more than 1s to start
- * and immediatly stopped once started
- *
- * const abortController = new AbortController()
- * setTimeout(() => { abortController.abort() }, 1000)
- * const server = await startServer({
- *   abortSignal: abortController.signal
- * })
- * await server.stop()
- *
- * In order to implement this kind of API two helpers are exported
- * here:
- * 1. "Abort" which can be used to throw an abort error
- *   while server is starting
- * 2. "Cleanup" which can be used to track how to cleanup all the things
- *   done to start the server
- *
- * Same concepts could be reused when spwaning a child process, a worker, etc..
- *
- */
-
-export { Abortable } from "./abortable.js"
-
-// when will be a package this should be a Node.js export only
-export { raceProcessTeardownEvents } from "./process_teardown_events.js"