@jsenv/core 23.1.3 → 23.2.2

package/src/abort/callback_list.js

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,34 @@
+/*
+ * 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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,32 @@
+/*
+ * 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"

package/src/abort/process_teardown_events.js

@@ -0,0 +1,59 @@
+import { raceCallbacks } from "./callback_race.js"
+
+export const raceProcessTeardownEvents = (processTeardownEvents, callback) => {
+  return raceCallbacks(
+    {
+      ...(processTeardownEvents.SIGHUP ? SIGHUP_CALLBACK : {}),
+      ...(processTeardownEvents.SIGTERM ? SIGTERM_CALLBACK : {}),
+      ...(processTeardownEvents.SIGINT ? SIGINT_CALLBACK : {}),
+      ...(processTeardownEvents.beforeExit ? BEFORE_EXIT_CALLBACK : {}),
+      ...(processTeardownEvents.exit ? EXIT_CALLBACK : {}),
+    },
+    callback,
+  )
+}
+
+const SIGHUP_CALLBACK = {
+  SIGHUP: (cb) => {
+    process.on("SIGHUP", cb)
+    return () => {
+      process.removeListener("SIGHUP", cb)
+    }
+  },
+}
+
+const SIGTERM_CALLBACK = {
+  SIGTERM: (cb) => {
+    process.on("SIGTERM", cb)
+    return () => {
+      process.removeListener("SIGTERM", cb)
+    }
+  },
+}
+
+const BEFORE_EXIT_CALLBACK = {
+  beforeExit: (cb) => {
+    process.on("beforeExit", cb)
+    return () => {
+      process.removeListener("beforeExit", cb)
+    }
+  },
+}
+
+const EXIT_CALLBACK = {
+  exit: (cb) => {
+    process.on("exit", cb)
+    return () => {
+      process.removeListener("exit", cb)
+    }
+  },
+}
+
+const SIGINT_CALLBACK = {
+  SIGINT: (cb) => {
+    process.on("SIGINT", cb)
+    return () => {
+      process.removeListener("SIGINT", cb)
+    }
+  },
+}

package/src/buildProject.js

@@ -1,11 +1,10 @@
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
-import {
-  createCancellationToken,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
 import { resolveDirectoryUrl } from "@jsenv/filesystem"
 
-import { executeJsenvAsyncFunction } from "./internal/executeJsenvAsyncFunction.js"
+import {
+  Abortable,
+  raceProcessTeardownEvents,
+} from "@jsenv/core/src/abort/main.js"
 import { COMPILE_ID_BEST } from "./internal/CONSTANTS.js"
 import {
   assertProjectDirectoryUrl,
@@ -19,8 +18,8 @@ import {
 } from "./internal/generateGroupMap/jsenvRuntimeSupport.js"
 
 export const buildProject = async ({
-  cancellationToken = createCancellationToken(),
-  cancelOnSIGINT = false,
+  signal = new AbortController().signal,
+  handleSIGINT = true,
   logLevel = "info",
   compileServerLogLevel = "warn",
   logger,
@@ -103,141 +102,151 @@ export const buildProject = async ({
   // (to fix that sourcemap could be inlined)
   filesystemCache = true,
 }) => {
-  const jsenvBuildFunction = async ({ jsenvCancellationToken }) => {
-    cancellationToken = composeCancellationToken(
-      cancellationToken,
-      jsenvCancellationToken,
+  logger = logger || createLogger({ logLevel })
+  if (!["esmodule", "systemjs", "commonjs", "global"].includes(format)) {
+    throw new TypeError(
+      `unexpected format: ${format}. Must be "esmodule", "systemjs", "commonjs" or "global".`,
     )
+  }
+  if (typeof runtimeSupport !== "object" || runtimeSupport === null) {
+    throw new TypeError(
+      `runtimeSupport must be an object, got ${runtimeSupport}`,
+    )
+  }
 
-    logger = logger || createLogger({ logLevel })
-    if (!["esmodule", "systemjs", "commonjs", "global"].includes(format)) {
-      throw new TypeError(
-        `unexpected format: ${format}. Must be "esmodule", "systemjs", "commonjs" or "global".`,
-      )
-    }
-    if (typeof runtimeSupport !== "object" || runtimeSupport === null) {
-      throw new TypeError(
-        `runtimeSupport must be an object, got ${runtimeSupport}`,
-      )
-    }
-
-    projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-    await assertProjectDirectoryExists({ projectDirectoryUrl })
+  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
+  await assertProjectDirectoryExists({ projectDirectoryUrl })
 
-    assertEntryPointMap({ entryPointMap })
+  assertEntryPointMap({ entryPointMap })
 
-    if (Object.keys(entryPointMap).length === 0) {
-      logger.error(`entryPointMap is an empty object`)
-      return {
-        rollupBuilds: {},
-      }
+  if (Object.keys(entryPointMap).length === 0) {
+    logger.error(`entryPointMap is an empty object`)
+    return {
+      rollupBuilds: {},
     }
+  }
 
-    assertBuildDirectoryRelativeUrl({ buildDirectoryRelativeUrl })
-    const buildDirectoryUrl = resolveDirectoryUrl(
-      buildDirectoryRelativeUrl,
-      projectDirectoryUrl,
+  assertBuildDirectoryRelativeUrl({ buildDirectoryRelativeUrl })
+  const buildDirectoryUrl = resolveDirectoryUrl(
+    buildDirectoryRelativeUrl,
+    projectDirectoryUrl,
+  )
+  assertBuildDirectoryInsideProject({
+    buildDirectoryUrl,
+    projectDirectoryUrl,
+  })
+
+  const buildOperation = Abortable.fromSignal(signal)
+  if (handleSIGINT) {
+    Abortable.effect(buildOperation, (cb) =>
+      raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        cb,
+      ),
     )
-    assertBuildDirectoryInsideProject({
-      buildDirectoryUrl,
-      projectDirectoryUrl,
-    })
+  }
 
-    const compileServer = await startCompileServer({
-      cancellationToken,
-      compileServerLogLevel,
+  const compileServer = await startCompileServer({
+    signal: buildOperation.signal,
+    compileServerLogLevel,
+
+    projectDirectoryUrl,
+    jsenvDirectoryRelativeUrl,
+    jsenvDirectoryClean,
+    // build compiled files are written into a different directory
+    // than exploring-server. This is because here we compile for rollup
+    // that is expecting esmodule format, not systemjs
+    // + some more differences like import.meta.dev
+    outDirectoryName: "out-build",
+    importDefaultExtension,
+    moduleOutFormat: "esmodule", // rollup will transform into systemjs
+    importMetaFormat: format, // but ensure import.meta are correctly transformed into the right format
+
+    compileServerProtocol,
+    compileServerPrivateKey,
+    compileServerCertificate,
+    compileServerIp,
+    compileServerPort,
+    env,
+    babelPluginMap,
+    transformTopLevelAwait,
+    customCompilers,
+    runtimeSupport,
+
+    compileServerCanReadFromFileSystem: filesystemCache,
+    compileServerCanWriteOnFilesystem: filesystemCache,
+    // keep source html untouched
+    // here we don't need to inline importmap
+    // nor to inject jsenv script
+    transformHtmlSourceFiles: false,
+  })
+
+  buildOperation.cleaner.addCallback(async () => {
+    await compileServer.stop(`build cleanup`)
+  })
 
+  const { outDirectoryRelativeUrl, origin: compileServerOrigin } = compileServer
+
+  try {
+    const result = await buildUsingRollup({
+      buildOperation,
+      logger,
+
+      entryPointMap,
       projectDirectoryUrl,
-      jsenvDirectoryRelativeUrl,
-      jsenvDirectoryClean,
-      // build compiled files are written into a different directory
-      // than exploring-server. This is because here we compile for rollup
-      // that is expecting esmodule format, not systemjs
-      // + some more differences like import.meta.dev
-      outDirectoryName: "out-build",
+      compileServerOrigin,
+      compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${COMPILE_ID_BEST}/`,
+      buildDirectoryUrl,
+      buildDirectoryClean,
+      assetManifestFile,
+      assetManifestFileRelativeUrl,
+
+      urlMappings,
+      importResolutionMethod,
+      importMapFileRelativeUrl,
       importDefaultExtension,
-      moduleOutFormat: "esmodule", // rollup will transform into systemjs
-      importMetaFormat: format, // but ensure import.meta are correctly transformed into the right format
-
-      compileServerProtocol,
-      compileServerPrivateKey,
-      compileServerCertificate,
-      compileServerIp,
-      compileServerPort,
-      env,
+      externalImportSpecifiers,
+      externalImportUrlPatterns,
+      importPaths,
+
+      format,
+      systemJsUrl,
+      globalName,
+      globals,
       babelPluginMap,
       transformTopLevelAwait,
-      customCompilers,
       runtimeSupport,
 
-      compileServerCanReadFromFileSystem: filesystemCache,
-      compileServerCanWriteOnFilesystem: filesystemCache,
-      // keep source html untouched
-      // here we don't need to inline importmap
-      // nor to inject jsenv script
-      transformHtmlSourceFiles: false,
+      urlVersioning,
+      lineBreakNormalization,
+      useImportMapToMaximizeCacheReuse,
+      preserveEntrySignatures,
+      jsConcatenation,
+
+      minify,
+      minifyHtmlOptions,
+      minifyJsOptions,
+      minifyCssOptions,
+
+      serviceWorkers,
+      serviceWorkerFinalizer,
+
+      writeOnFileSystem,
+      sourcemapExcludeSources,
     })
 
-    const { outDirectoryRelativeUrl, origin: compileServerOrigin } =
-      compileServer
-
-    try {
-      const result = await buildUsingRollup({
-        cancellationToken,
-        logger,
-
-        entryPointMap,
-        projectDirectoryUrl,
-        compileServerOrigin,
-        compileDirectoryRelativeUrl: `${outDirectoryRelativeUrl}${COMPILE_ID_BEST}/`,
-        buildDirectoryUrl,
-        buildDirectoryClean,
-        assetManifestFile,
-        assetManifestFileRelativeUrl,
-
-        urlMappings,
-        importResolutionMethod,
-        importMapFileRelativeUrl,
-        importDefaultExtension,
-        externalImportSpecifiers,
-        externalImportUrlPatterns,
-        importPaths,
-
-        format,
-        systemJsUrl,
-        globalName,
-        globals,
-        babelPluginMap,
-        transformTopLevelAwait,
-        runtimeSupport,
-
-        urlVersioning,
-        lineBreakNormalization,
-        useImportMapToMaximizeCacheReuse,
-        preserveEntrySignatures,
-        jsConcatenation,
-
-        minify,
-        minifyHtmlOptions,
-        minifyJsOptions,
-        minifyCssOptions,
-
-        serviceWorkers,
-        serviceWorkerFinalizer,
-
-        writeOnFileSystem,
-        sourcemapExcludeSources,
-      })
-
-      return result
-    } finally {
-      compileServer.stop("build generated")
+    return result
+  } catch (e) {
+    if (Abortable.isAbortError(e)) {
+      logger.info("build aborted")
+      return null
     }
+    throw e
+  } finally {
+    await buildOperation.cleaner.clean()
   }
-
-  return executeJsenvAsyncFunction(jsenvBuildFunction, {
-    cancelOnSIGINT,
-  })
 }
 
 const assertEntryPointMap = ({ entryPointMap }) => {