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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "27.0.0-alpha.82",
+  "version": "27.0.0-alpha.83",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "author": {
@@ -74,7 +74,7 @@
     "@jsenv/node-esm-resolution": "0.1.0",
     "@jsenv/server": "12.7.0",
     "@jsenv/uneval": "1.6.0",
-    "@jsenv/utils": "1.9.1",
+    "@jsenv/utils": "1.9.2",
     "@jsenv/url-meta": "7.0.0",
     "@jsenv/urls": "1.2.5",
     "construct-style-sheets-polyfill": "3.1.0",

package/src/build/start_build_server.js

@@ -13,7 +13,6 @@
  * we want to be in the user shoes and we should not alter build files.
  */
 
-import { parentPort } from "node:worker_threads"
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
@@ -22,15 +21,17 @@ import {
   pluginCORS,
   fetchFileSystem,
   composeServices,
+  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"
 
 export const startBuildServer = async ({
   signal = new AbortController().signal,
@@ -56,10 +57,9 @@ export const startBuildServer = async ({
   buildServerMainFile = 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
   buildServerAutoreload = typeof process.send !== "function" &&
-    !parentPort &&
     !process.env.VSCODE_INSPECTOR_OPTIONS,
   cooldownBetweenFileEvents,
 }) => {
@@ -67,25 +67,29 @@ export const startBuildServer = async ({
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
   buildDirectoryUrl = assertAndNormalizeDirectoryUrl(buildDirectoryUrl)
 
-  const reloadableProcess = await initReloadableProcess({
-    signal,
-    handleSIGINT,
-    ...(buildServerAutoreload
-      ? {
-          enabled: true,
-          logLevel: "info",
-          fileToRestart: buildServerMainFile,
-        }
-      : {
-          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(buildServerMainFile)
+  if (buildServerAutoreload && reloadableWorker.isPrimary) {
     const buildServerFileChangeCallback = ({ relativeUrl, event }) => {
       const url = new URL(relativeUrl, rootDirectoryUrl).href
       if (buildServerAutoreload) {
         logger.info(`file ${event} ${url} -> restarting server...`)
-        reloadableProcess.reload()
+        reloadableWorker.reload()
       }
     }
     const stopWatchingBuildServerFiles = registerDirectoryLifecycle(
@@ -109,19 +113,19 @@ export const startBuildServer = async ({
         },
       },
     )
-    signal.addEventListener("abort", () => {
+    operation.addAbortCallback(() => {
       stopWatchingBuildServerFiles()
+      reloadableWorker.terminate()
     })
+    await reloadableWorker.load()
     return {
       origin: `${protocol}://127.0.0.1:${port}`,
       stop: () => {
         stopWatchingBuildServerFiles()
-
-        reloadableProcess.stop()
+        reloadableWorker.terminate()
       },
     }
   }
-  signal = reloadableProcess.signal
 
   const startBuildServerTask = createTaskLog("start build server", {
     disabled: !loggerToLevels(logger).info,
@@ -170,7 +174,6 @@ export const startBuildServer = async ({
     logger.info(`- ${server.origins[key]}`)
   })
   logger.info(``)
-
   return {
     origin: server.origin,
     stop: () => {

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,16 @@ export const startDevServer = async ({
         },
       },
     )
-    signal.addEventListener("abort", () => {
-      unregisterDevServerFilesWatcher()
+    operation.addAbortCallback(() => {
+      stopWatchingDevServerFiles()
+      reloadableWorker.terminate()
     })
+    await reloadableWorker.load()
     return {
       origin: `${protocol}://127.0.0.1:${port}`,
       stop: () => {
-        unregisterDevServerFilesWatcher()
-        reloadableProcess.stop()
+        stopWatchingDevServerFiles()
+        reloadableWorker.terminate()
       },
     }
   }

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

@@ -9,10 +9,11 @@ import {
 } 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 { 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,
   browserVersion,

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,56 @@
+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)
+    })
+    worker.once("exit", () => {
+      worker = null
+    })
+    await new Promise((resolve) => {
+      worker.once("online", resolve)
+    })
+  }
+
+  const reload = async () => {
+    await terminate()
+    await load()
+  }
+
+  return {
+    isPrimary,
+    load,
+    reload,
+    terminate,
+  }
+}

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,

package/src/plugins/autoreload/dev_sse/jsenv_plugin_dev_sse_server.js

@@ -1,7 +1,7 @@
 import { urlToRelativeUrl } from "@jsenv/urls"
 import { createCallbackList } from "@jsenv/abort"
 
-import { createSSEService } from "@jsenv/utils/event_source/sse_service.js"
+import { createSSEService } from "@jsenv/core/src/helpers/event_source/sse_service.js"
 
 export const jsenvPluginDevSSEServer = ({
   rootDirectoryUrl,

package/src/test/coverage/babel_plugin_instrument.js

@@ -0,0 +1,82 @@
+import { URL_META } from "@jsenv/url-meta"
+import { fileSystemPathToUrl } from "@jsenv/urls"
+
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+
+// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+
+export const babelPluginInstrument = (
+  api,
+  {
+    rootDirectoryUrl,
+    useInlineSourceMaps = false,
+    coverageConfig = { "./**/*": true },
+  },
+) => {
+  const { programVisitor } = requireFromJsenv("istanbul-lib-instrument")
+
+  const { types } = api
+
+  const associations = URL_META.resolveAssociations(
+    { cover: coverageConfig },
+    rootDirectoryUrl,
+  )
+  const shouldInstrument = (url) => {
+    return URL_META.applyAssociations({ url, associations }).cover
+  }
+
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path) {
+          const { file } = this
+          const { opts } = file
+          if (!opts.sourceFileName) {
+            console.warn(
+              `cannot instrument file when "sourceFileName" option is not set`,
+            )
+            return
+          }
+          const fileUrl = fileSystemPathToUrl(opts.sourceFileName)
+          if (!shouldInstrument(fileUrl)) {
+            return
+          }
+
+          this.__dv__ = null
+
+          let inputSourceMap
+
+          if (useInlineSourceMaps) {
+            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
+            inputSourceMap =
+              opts.inputSourceMap || file.inputMap
+                ? file.inputMap.sourcemap
+                : null
+          } else {
+            inputSourceMap = opts.inputSourceMap
+          }
+
+          this.__dv__ = programVisitor(
+            types,
+            opts.filenameRelative || opts.filename,
+            {
+              coverageVariable: "__coverage__",
+              inputSourceMap,
+            },
+          )
+          this.__dv__.enter(path)
+        },
+
+        exit(path) {
+          if (!this.__dv__) {
+            return
+          }
+          const object = this.__dv__.exit(path)
+          // object got two properties: fileCoverage and sourceMappingURL
+          this.file.metadata.coverage = object.fileCoverage
+        },
+      },
+    },
+  }
+}