@jsenv/core 27.0.0-alpha.82 → 27.0.0-alpha.85

package/src/dev/start_dev_server.js

@@ -1,12 +1,13 @@
-import { parentPort } from "node:worker_threads"
-
+import { findFreePort } from "@jsenv/server"
 import {
   assertAndNormalizeDirectoryUrl,
   registerDirectoryLifecycle,
 } from "@jsenv/filesystem"
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { createLogger, loggerToLevels, createTaskLog } from "@jsenv/log"
 import { getCallerPosition } from "@jsenv/urls"
-import { initReloadableProcess } from "@jsenv/utils/process_reload/process_reload.js"
+
+import { createReloadableWorker } from "@jsenv/core/src/helpers/worker_reload.js"
 import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
 import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
@@ -17,7 +18,7 @@ import { jsenvPluginExplorer } from "./plugins/explorer/jsenv_plugin_explorer.js
 
 export const startDevServer = async ({
   signal = new AbortController().signal,
-  handleSIGINT,
+  handleSIGINT = true,
   logLevel = "info",
   omegaServerLogLevel = "warn",
   port = 3456,
@@ -37,10 +38,9 @@ export const startDevServer = async ({
   devServerMainFile = getCallerPosition().url,
   // force disable server autoreload when this code is executed:
   // - inside a forked child process
-  // - inside a worker thread
-  // (because node cluster won't work)
+  // - debugged by vscode
+  // otherwise we get net:ERR_CONNECTION_REFUSED
   devServerAutoreload = typeof process.send !== "function" &&
-    !parentPort &&
     !process.env.VSCODE_INSPECTOR_OPTIONS,
   clientFiles = {
     "./src/": true,
@@ -80,28 +80,30 @@ export const startDevServer = async ({
 }) => {
   const logger = createLogger({ logLevel })
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
-  const reloadableProcess = await initReloadableProcess({
-    signal,
-    handleSIGINT,
-    ...(devServerAutoreload
-      ? {
-          enabled: true,
-          logLevel: "warn",
-          fileToRestart: devServerMainFile,
-        }
-      : {
-          enabled: false,
-        }),
-  })
-  if (reloadableProcess.isPrimary) {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+  if (handleSIGINT) {
+    operation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        abort,
+      )
+    })
+  }
+  if (port === 0) {
+    port = await findFreePort(port, { signal: operation.signal })
+  }
+
+  const reloadableWorker = createReloadableWorker(devServerMainFile)
+  if (devServerAutoreload && reloadableWorker.isPrimary) {
     const devServerFileChangeCallback = ({ relativeUrl, event }) => {
       const url = new URL(relativeUrl, rootDirectoryUrl).href
-      if (devServerAutoreload) {
-        logger.info(`file ${event} ${url} -> restarting server...`)
-        reloadableProcess.reload()
-      }
+      logger.info(`file ${event} ${url} -> restarting server...`)
+      reloadableWorker.reload()
     }
-    const unregisterDevServerFilesWatcher = registerDirectoryLifecycle(
+    const stopWatchingDevServerFiles = registerDirectoryLifecycle(
       rootDirectoryUrl,
       {
         watchPatterns: {
@@ -122,14 +124,20 @@ export const startDevServer = async ({
         },
       },
     )
-    signal.addEventListener("abort", () => {
-      unregisterDevServerFilesWatcher()
+    operation.addAbortCallback(() => {
+      stopWatchingDevServerFiles()
+      reloadableWorker.terminate()
     })
+
+    const worker = await reloadableWorker.load()
+    if (!keepProcessAlive) {
+      worker.unref()
+    }
     return {
       origin: `${protocol}://127.0.0.1:${port}`,
       stop: () => {
-        unregisterDevServerFilesWatcher()
-        reloadableProcess.stop()
+        stopWatchingDevServerFiles()
+        reloadableWorker.terminate()
       },
     }
   }

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

@@ -8,10 +8,11 @@ import {
   raceCallbacks,
 } from "@jsenv/abort"
 import { moveUrl } from "@jsenv/urls"
-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 { memoize } from "@jsenv/utils/src/memoize/memoize.js"
+import { escapeRegexpSpecialChars } from "@jsenv/utils/src/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,

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

@@ -5,10 +5,10 @@ import {
   createCallbackListNotifiedOnce,
 } from "@jsenv/abort"
 import { uneval } from "@jsenv/uneval"
-
 import { urlToFileSystemPath } from "@jsenv/urls"
 import { createDetailedMessage } from "@jsenv/log"
-import { memoize } from "@jsenv/utils/memoize/memoize.js"
+import { memoize } from "@jsenv/utils/src/memoize/memoize.js"
+
 import { createChildExecOptions } from "./child_exec_options.js"
 import { ExecOptions } from "./exec_options.js"
 import { killProcessTree } from "./kill_process_tree.js"

package/src/helpers/command/command.js

@@ -0,0 +1,73 @@
+import { exec } from "node:child_process"
+import { createDetailedMessage, createLogger, UNICODE } from "@jsenv/log"
+
+export const executeCommand = (
+  command,
+  {
+    logLevel = "info",
+    signal = new AbortController().signal,
+    onStdout = () => {},
+    onStderr = () => {},
+    cwd,
+    env,
+    timeout,
+  } = {},
+) => {
+  const logger = createLogger({ logLevel })
+
+  return new Promise((resolve, reject) => {
+    logger.debug(`${UNICODE.COMMAND} ${command}`)
+    const commandProcess = exec(command, {
+      signal,
+      cwd:
+        cwd && typeof cwd === "string" && cwd.startsWith("file:")
+          ? new URL(cwd)
+          : cwd,
+      env,
+      timeout,
+      silent: true,
+    })
+    commandProcess.on("error", (error) => {
+      if (error && error.code === "ETIMEDOUT") {
+        logger.error(`timeout after ${timeout} ms`)
+        reject(error)
+      } else {
+        reject(error)
+      }
+    })
+    const stdoutDatas = []
+    commandProcess.stdout.on("data", (data) => {
+      stdoutDatas.push(data)
+      logger.debug(data)
+      onStderr(data)
+    })
+    let stderrDatas = []
+    commandProcess.stderr.on("data", (data) => {
+      stderrDatas.push(data)
+      logger.debug(data)
+      onStdout(data)
+    })
+    if (commandProcess.stdin) {
+      commandProcess.stdin.on("error", (error) => {
+        reject(error)
+      })
+    }
+    commandProcess.on("exit", (exitCode, signal) => {
+      if (signal) {
+        reject(new Error(`killed with ${signal}`))
+      }
+      if (exitCode) {
+        reject(
+          new Error(
+            createDetailedMessage(`failed with exit code ${exitCode}`, {
+              "command stderr": stderrDatas.join(""),
+              // "command stdout": stdoutDatas.join(""),
+            }),
+          ),
+        )
+        return
+      }
+      resolve({ exitCode, signal })
+    })
+  })
+}

package/src/helpers/event_source/event_source.js

@@ -0,0 +1,197 @@
+/* eslint-env browser */
+
+export const createEventSourceConnection = (
+  eventSourceUrl,
+  events = {},
+  { retryMaxAttempt = Infinity, retryAllocatedMs = Infinity, lastEventId } = {},
+) => {
+  const { EventSource } = window
+  if (typeof EventSource !== "function") {
+    return () => {}
+  }
+
+  const eventSourceOrigin = new URL(eventSourceUrl).origin
+  Object.keys(events).forEach((eventName) => {
+    const eventCallback = events[eventName]
+    events[eventName] = (e) => {
+      if (e.origin === eventSourceOrigin) {
+        if (e.lastEventId) {
+          lastEventId = e.lastEventId
+        }
+        eventCallback(e)
+      }
+    }
+  })
+
+  const status = {
+    value: "default",
+    goTo: (value) => {
+      if (value === status.value) {
+        return
+      }
+      status.value = value
+      status.onchange()
+    },
+    onchange: () => {},
+  }
+  let _disconnect = () => {}
+
+  const attemptConnection = (url) => {
+    const eventSource = new EventSource(url, {
+      withCredentials: true,
+    })
+    _disconnect = () => {
+      if (status.value !== "connecting" && status.value !== "connected") {
+        console.warn(
+          `disconnect() ignored because connection is ${status.value}`,
+        )
+        return
+      }
+      eventSource.onerror = undefined
+      eventSource.close()
+      Object.keys(events).forEach((eventName) => {
+        eventSource.removeEventListener(eventName, events[eventName])
+      })
+      status.goTo("disconnected")
+    }
+    let retryCount = 0
+    let firstRetryMs = Date.now()
+    eventSource.onerror = (errorEvent) => {
+      if (errorEvent.target.readyState === EventSource.CONNECTING) {
+        if (retryCount > retryMaxAttempt) {
+          console.info(`could not connect after ${retryMaxAttempt} attempt`)
+          _disconnect()
+          return
+        }
+
+        if (retryCount === 0) {
+          firstRetryMs = Date.now()
+        } else {
+          const allRetryDuration = Date.now() - firstRetryMs
+          if (retryAllocatedMs && allRetryDuration > retryAllocatedMs) {
+            console.info(
+              `could not connect in less than ${retryAllocatedMs} ms`,
+            )
+            _disconnect()
+            return
+          }
+        }
+
+        retryCount++
+        status.goTo("connecting")
+        return
+      }
+
+      if (errorEvent.target.readyState === EventSource.CLOSED) {
+        _disconnect()
+        return
+      }
+    }
+    eventSource.onopen = () => {
+      status.goTo("connected")
+    }
+    Object.keys(events).forEach((eventName) => {
+      eventSource.addEventListener(eventName, events[eventName])
+    })
+    if (!events.hasOwnProperty("welcome")) {
+      eventSource.addEventListener("welcome", (e) => {
+        if (e.origin === eventSourceOrigin && e.lastEventId) {
+          lastEventId = e.lastEventId
+        }
+      })
+    }
+    status.goTo("connecting")
+  }
+
+  let connect = () => {
+    attemptConnection(eventSourceUrl)
+    connect = () => {
+      attemptConnection(
+        lastEventId
+          ? addLastEventIdIntoUrlSearchParams(eventSourceUrl, lastEventId)
+          : eventSourceUrl,
+      )
+    }
+  }
+
+  const removePageUnloadListener = listenPageUnload(() => {
+    if (status.value === "connecting" || status.value === "connected") {
+      _disconnect()
+    }
+  })
+
+  const destroy = () => {
+    removePageUnloadListener()
+    _disconnect()
+  }
+
+  return {
+    status,
+    connect,
+    disconnect: () => _disconnect(),
+    destroy,
+  }
+}
+
+const addLastEventIdIntoUrlSearchParams = (url, lastEventId) => {
+  if (url.indexOf("?") === -1) {
+    url += "?"
+  } else {
+    url += "&"
+  }
+  return `${url}last-event-id=${encodeURIComponent(lastEventId)}`
+}
+
+// const listenPageMightFreeze = (callback) => {
+//   const removePageHideListener = listenEvent(window, "pagehide", (pageHideEvent) => {
+//     if (pageHideEvent.persisted === true) {
+//       callback(pageHideEvent)
+//     }
+//   })
+//   return removePageHideListener
+// }
+
+// const listenPageFreeze = (callback) => {
+//   const removeFreezeListener = listenEvent(document, "freeze", (freezeEvent) => {
+//     callback(freezeEvent)
+//   })
+//   return removeFreezeListener
+// }
+
+// const listenPageIsRestored = (callback) => {
+//   const removeResumeListener = listenEvent(document, "resume", (resumeEvent) => {
+//     removePageshowListener()
+//     callback(resumeEvent)
+//   })
+//   const removePageshowListener = listenEvent(window, "pageshow", (pageshowEvent) => {
+//     if (pageshowEvent.persisted === true) {
+//       removePageshowListener()
+//       removeResumeListener()
+//       callback(pageshowEvent)
+//     }
+//   })
+//   return () => {
+//     removeResumeListener()
+//     removePageshowListener()
+//   }
+// }
+
+const listenPageUnload = (callback) => {
+  const removePageHideListener = listenEvent(
+    window,
+    "pagehide",
+    (pageHideEvent) => {
+      if (pageHideEvent.persisted !== true) {
+        callback(pageHideEvent)
+      }
+    },
+  )
+  return removePageHideListener
+}
+
+const listenEvent = (emitter, event, callback) => {
+  emitter.addEventListener(event, callback)
+  return () => {
+    emitter.removeEventListener(event, callback)
+  }
+}

package/src/helpers/event_source/sse_service.js

@@ -0,0 +1,53 @@
+import { createSSERoom } from "@jsenv/server"
+import { createCallbackListNotifiedOnce } from "@jsenv/abort"
+
+export const createSSEService = ({ serverEventCallbackList }) => {
+  const destroyCallbackList = createCallbackListNotifiedOnce()
+
+  const cache = []
+  const sseRoomLimit = 100
+  const getOrCreateSSERoom = (request) => {
+    const htmlFileRelativeUrl = request.ressource.slice(1)
+    const cacheEntry = cache.find(
+      (cacheEntryCandidate) =>
+        cacheEntryCandidate.htmlFileRelativeUrl === htmlFileRelativeUrl,
+    )
+    if (cacheEntry) {
+      return cacheEntry.sseRoom
+    }
+    const sseRoom = createSSERoom({
+      retryDuration: 2000,
+      historyLength: 100,
+      welcomeEventEnabled: true,
+      effect: () => {
+        return serverEventCallbackList.add((event) => {
+          sseRoom.sendEvent(event)
+        })
+      },
+    })
+    const removeSSECleanupCallback = destroyCallbackList.add(() => {
+      removeSSECleanupCallback()
+      sseRoom.close()
+    })
+    cache.push({
+      htmlFileRelativeUrl,
+      sseRoom,
+      cleanup: () => {
+        removeSSECleanupCallback()
+        sseRoom.close()
+      },
+    })
+    if (cache.length >= sseRoomLimit) {
+      const firstCacheEntry = cache.shift()
+      firstCacheEntry.cleanup()
+    }
+    return sseRoom
+  }
+
+  return {
+    getOrCreateSSERoom,
+    destroy: () => {
+      destroyCallbackList.notify()
+    },
+  }
+}

package/src/helpers/worker_reload.js

@@ -0,0 +1,57 @@
+import { fileURLToPath } from "node:url"
+import { Worker, workerData } from "node:worker_threads"
+
+// https://nodejs.org/api/worker_threads.html
+export const createReloadableWorker = (workerFileUrl, options = {}) => {
+  const workerFilePath = fileURLToPath(workerFileUrl)
+  const isPrimary = !workerData || workerData.workerFilePath !== workerFilePath
+  let worker
+
+  const terminate = async () => {
+    if (worker) {
+      let _worker = worker
+      worker = null
+      const exitPromise = new Promise((resolve) => {
+        _worker.once("exit", resolve)
+      })
+      _worker.terminate()
+      await exitPromise
+    }
+  }
+
+  const load = async () => {
+    if (!isPrimary) {
+      throw new Error(`worker can be loaded from primary file only`)
+    }
+    worker = new Worker(workerFilePath, {
+      ...options,
+      workerData: {
+        ...options.workerData,
+        workerFilePath,
+      },
+    })
+
+    worker.once("error", (error) => {
+      console.error(error)
+    })
+    await new Promise((resolve) => {
+      worker.once("online", resolve)
+    })
+    worker.once("exit", () => {
+      worker = null
+    })
+    return worker
+  }
+
+  const reload = async () => {
+    await terminate()
+    await load()
+  }
+
+  return {
+    isPrimary,
+    load,
+    reload,
+    terminate,
+  }
+}

package/src/omega/compat/runtime_compat.js

@@ -1,4 +1,5 @@
-import { findHighestVersion } from "@jsenv/utils/semantic_versioning/highest_version.js"
+import { findHighestVersion } from "@jsenv/utils/src/semantic_versioning/highest_version.js"
+
 import { featureCompats } from "./features_compats.js"
 
 export const RUNTIME_COMPAT = {

package/src/omega/kitchen.js

@@ -8,7 +8,8 @@ import {
 } from "@jsenv/urls"
 import { writeFileSync, ensureWindowsDriveLetter } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/log"
-import { CONTENT_TYPE } from "@jsenv/utils/content_type/content_type.js"
+import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js"
+
 import { createPluginController } from "../plugins/plugin_controller.js"
 import { urlSpecifierEncoding } from "./url_specifier_encoding.js"
 import { createUrlInfoTransformer } from "./url_graph/url_info_transformations.js"
@@ -711,6 +712,8 @@ const memoizeCook = (cook) => {
 const applyReferenceEffectsOnUrlInfo = (reference, urlInfo, context) => {
   if (reference.shouldHandle) {
     urlInfo.shouldHandle = true
+  } else {
+    urlInfo.shouldHandle = false
   }
   urlInfo.originalUrl = urlInfo.originalUrl || reference.url
 

package/src/omega/server/user_agent.js

@@ -1,4 +1,5 @@
-import { memoizeByFirstArgument } from "@jsenv/utils/memoize/memoize_by_first_argument.js"
+import { memoizeByFirstArgument } from "@jsenv/utils/src/memoize/memoize_by_first_argument.js"
+
 import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
 
 export const parseUserAgentHeader = memoizeByFirstArgument((userAgent) => {

package/src/omega/url_graph/sort_by_dependencies.js

@@ -0,0 +1,27 @@
+export const sortByDependencies = (nodes) => {
+  const visited = []
+  const sorted = []
+  const circular = []
+  const visit = (url) => {
+    const isSorted = sorted.includes(url)
+    if (isSorted) {
+      return
+    }
+    const isVisited = visited.includes(url)
+    if (isVisited) {
+      circular.push(url)
+      sorted.push(url)
+    } else {
+      visited.push(url)
+      nodes[url].dependencies.forEach((dependencyUrl) => {
+        visit(dependencyUrl, url)
+      })
+      sorted.push(url)
+    }
+  }
+  Object.keys(nodes).forEach((url) => {
+    visit(url)
+  })
+  sorted.circular = circular
+  return sorted
+}

package/src/omega/url_graph/url_info_transformations.js

@@ -1,12 +1,12 @@
+import { pathToFileURL } from "node:url"
 import { bufferToEtag } from "@jsenv/filesystem"
-import { urlToRelativeUrl } from "@jsenv/urls"
-
-import { composeTwoSourcemaps } from "@jsenv/utils/sourcemap/sourcemap_composition_v3.js"
+import { urlToRelativeUrl, isFileSystemPath } from "@jsenv/urls"
 import {
+  composeTwoSourcemaps,
   SOURCEMAP,
-  sourcemapToBase64Url,
-  generateSourcemapUrl,
-} from "@jsenv/utils/sourcemap/sourcemap_utils.js"
+  generateSourcemapFileUrl,
+  generateSourcemapDataUrl,
+} from "@jsenv/sourcemap"
 
 export const createUrlInfoTransformer = ({
   logger,
@@ -23,18 +23,25 @@ export const createUrlInfoTransformer = ({
     sourcemaps === "programmatic"
 
   const normalizeSourcemap = (urlInfo, sourcemap) => {
+    let { sources } = sourcemap
+    if (sources) {
+      sources = sources.map((source) => {
+        if (source && isFileSystemPath(source)) {
+          return String(pathToFileURL(source))
+        }
+        return source
+      })
+    }
     const wantSourcesContent =
       // for inline content (<script> insdide html)
       // chrome won't be able to fetch the file as it does not exists
       // so sourcemap must contain sources
       sourcemapsSourcesContent ||
       urlInfo.isInline ||
-      (sourcemap.sources &&
-        sourcemap.sources.some(
-          (source) => !source || !source.startsWith("file:"),
-        ))
-    if (sourcemap.sources && sourcemap.sources.length > 1) {
-      sourcemap.sources = sourcemap.sources.map(
+      (sources &&
+        sources.some((source) => !source || !source.startsWith("file:")))
+    if (sources && sources.length > 1) {
+      sourcemap.sources = sources.map(
         (source) => new URL(source, urlInfo.originalUrl).href,
       )
       if (!wantSourcesContent) {
@@ -65,7 +72,9 @@ export const createUrlInfoTransformer = ({
     // when jsenv is done cooking the file
     //   during build it's urlInfo.url to be inside the build
     //   but otherwise it's generatedUrl to be inside .jsenv/ directory
-    urlInfo.sourcemapGeneratedUrl = generateSourcemapUrl(urlInfo.generatedUrl)
+    urlInfo.sourcemapGeneratedUrl = generateSourcemapFileUrl(
+      urlInfo.generatedUrl,
+    )
     const [sourcemapReference, sourcemapUrlInfo] = injectSourcemapPlaceholder({
       urlInfo,
       specifier: urlInfo.sourcemapGeneratedUrl,
@@ -154,7 +163,8 @@ export const createUrlInfoTransformer = ({
       }
       sourcemapUrlInfo.content = JSON.stringify(sourcemap, null, "  ")
       if (sourcemaps === "inline") {
-        sourcemapReference.generatedSpecifier = sourcemapToBase64Url(sourcemap)
+        sourcemapReference.generatedSpecifier =
+          generateSourcemapDataUrl(sourcemap)
       }
       if (sourcemaps === "file" || sourcemaps === "inline") {
         urlInfo.content = SOURCEMAP.writeComment({

package/src/plugins/autoreload/dev_sse/client/event_source_client.js

@@ -1,4 +1,4 @@
-import { createEventSourceConnection } from "@jsenv/utils/event_source/event_source.js"
+import { createEventSourceConnection } from "@jsenv/core/src/helpers/event_source/event_source.js"
 import { urlHotMetas } from "../../../import_meta_hot/client/import_meta_hot.js"
 import {
   isAutoreloadEnabled,