@jsenv/core 27.0.0-alpha.3 → 27.0.0-alpha.32

package/src/test/execute_plan.js

@@ -9,7 +9,7 @@ import {
   ensureEmptyDirectory,
   normalizeStructuredMetaMap,
   urlToMeta,
-  writeFile,
+  writeFileSync,
 } from "@jsenv/filesystem"
 import {
   createLogger,
@@ -22,7 +22,7 @@ import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import { babelPluginInstrument } from "@jsenv/utils/coverage/babel_plugin_instrument.js"
 import { reportToCoverage } from "@jsenv/utils/coverage/report_to_coverage.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
-import { getCorePlugins } from "@jsenv/core/src/omega/core_plugins.js"
+import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
 import { startOmegaServer } from "@jsenv/core/src/omega/omega_server.js"
 import { run } from "@jsenv/core/src/execute/run.js"
@@ -62,9 +62,13 @@ export const executePlan = async (
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
-    plugins = [],
-    scenario = "test",
-    sourcemaps = "inline",
+    scenario,
+    sourcemaps,
+    plugins,
+    injectedGlobals,
+    nodeEsmResolution,
+    fileSystemMagicResolution,
+    transpilation,
 
     protocol,
     privateKey,
@@ -132,12 +136,24 @@ export const executePlan = async (
         logger,
         rootDirectoryUrl,
         urlGraph,
+        scenario,
+        sourcemaps,
+        writeOnFileSystem: false,
         plugins: [
           ...plugins,
           ...getCorePlugins({
-            babel: {
-              getCustomBabelPlugins: ({ runtimeSupport }) => {
-                if (coverage && Object.keys(runtimeSupport)[0] !== "chrome") {
+            scenario,
+            htmlSupervisor: true,
+            nodeEsmResolution,
+            fileSystemMagicResolution,
+            injectedGlobals,
+            transpilation: {
+              ...transpilation,
+              getCustomBabelPlugins: ({ clientRuntimeCompat }) => {
+                if (
+                  coverage &&
+                  Object.keys(clientRuntimeCompat)[0] !== "chrome"
+                ) {
                   return {
                     "transform-instrument": [
                       babelPluginInstrument,
@@ -153,8 +169,6 @@ export const executePlan = async (
             },
           }),
         ],
-        scenario,
-        sourcemaps,
       })
       const serverLogger = createLogger({ logLevel: "warn" })
       const server = await startOmegaServer({
@@ -433,7 +447,7 @@ export const executePlan = async (
     }
     if (summary.counters.total !== summary.counters.completed) {
       const logFileUrl = new URL(logFileRelativeUrl, rootDirectoryUrl).href
-      writeFile(logFileUrl, rawOutput)
+      writeFileSync(logFileUrl, rawOutput)
       logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`)
     }
     const result = await transformReturnValue({

package/src/test/execute_test_plan.js

@@ -80,6 +80,12 @@ export const executeTestPlan = async ({
   // skip full means file with 100% coverage won't appear in coverage reports (log and html)
   coverageSkipFull = false,
 
+  sourcemaps = "inline",
+  plugins = [],
+  injectedGlobals,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+
   protocol,
   privateKey,
   certificate,
@@ -143,8 +149,8 @@ export const executeTestPlan = async ({
     logFileRelativeUrl,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
-
     rootDirectoryUrl,
+
     maxExecutionsInParallel,
     defaultMsAllocatedPerExecution,
     failFast,
@@ -159,6 +165,13 @@ export const executeTestPlan = async ({
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
+    scenario: "test",
+    sourcemaps,
+    plugins,
+    injectedGlobals,
+    nodeEsmResolution,
+    fileSystemMagicResolution,
+
     protocol,
     privateKey,
     certificate,

package/src/test/logs_file_execution.js

@@ -38,7 +38,8 @@ export const formatExecutionResult = (
   { completedExecutionLogAbbreviation, counters, memoryHeap },
 ) => {
   const { status } = executionResult
-  const description = descriptionFormatters[status]({
+  const descriptionFormatter = descriptionFormatters[status]
+  const description = descriptionFormatter({
     index: executionIndex,
     total: counters.total,
     executionParams,
@@ -52,7 +53,7 @@ export const formatExecutionResult = (
     return `${description} ${summary}`
   }
   const { consoleCalls = [], error, duration } = executionResult
-  const console = formatConsoleCalls(consoleCalls)
+  const consoleOutput = formatConsoleCalls(consoleCalls)
   return formatExecution({
     label: `${description} ${summary}`,
     details: {
@@ -61,7 +62,7 @@ export const formatExecutionResult = (
       duration: msAsDuration(duration),
       ...(error ? { error: error.stack } : {}),
     },
-    console,
+    consoleOutput,
   })
 }
 
@@ -203,21 +204,21 @@ const formatConsoleCalls = (consoleCalls) => {
   if (consoleOutputTrimmed === "") {
     return ""
   }
-  return `${ANSI.color(`-------- console --------`, ANSI.GREY)}
+  return `${ANSI.color(`-------- console output --------`, ANSI.GREY)}
 ${consoleOutputTrimmed}
 ${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
-const formatExecution = ({ label, details = {}, console }) => {
+const formatExecution = ({ label, details = {}, consoleOutput }) => {
   let message = ``
   message += label
   Object.keys(details).forEach((key) => {
     message += `
 ${key}: ${details[key]}`
   })
-  if (console) {
+  if (consoleOutput) {
     message += `
-${console}`
+${consoleOutput}`
   }
   return message
 }

package/src/build/plugins/minify_html/jsenv_plugin_minify_html.js

@@ -1,30 +0,0 @@
-import { createRequire } from "node:module"
-
-const require = createRequire(import.meta.url)
-
-// https://github.com/kangax/html-minifier#options-quick-reference
-export const jsenvPluginMinifyHtml = ({
-  collapseWhitespace = true,
-  removeComments = true,
-} = {}) => {
-  return {
-    name: "jsenv:minify_html",
-    appliesDuring: {
-      build: true,
-    },
-    optimize: {
-      html: async (htmlUrlInfo) => {
-        return minifyHtml(htmlUrlInfo.content, {
-          collapseWhitespace,
-          removeComments,
-        })
-      },
-    },
-  }
-}
-
-const minifyHtml = (htmlString, options) => {
-  const { minify } = require("html-minifier")
-  const htmlMinified = minify(htmlString, options)
-  return htmlMinified
-}

package/src/dev/plugins/autoreload/client/event_source_connection.js

@@ -1,195 +0,0 @@
-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/dev/plugins/autoreload/sse_service.js

@@ -1,149 +0,0 @@
-import { createSSERoom } from "@jsenv/server"
-import { registerDirectoryLifecycle } from "@jsenv/filesystem"
-import {
-  createCallbackList,
-  createCallbackListNotifiedOnce,
-} from "@jsenv/abort"
-
-export const createSSEService = ({
-  rootDirectoryUrl,
-  autoreloadPatterns,
-  onFileChange,
-  hotUpdateCallbackList,
-}) => {
-  const destroyCallbackList = createCallbackListNotifiedOnce()
-  const projectFileModified = createCallbackList()
-  const projectFileRemoved = createCallbackList()
-  const projectFileAdded = createCallbackList()
-  const watchProjectFiles = (callback) => {
-    const removeModifiedCallback = projectFileModified.add((relativeUrl) => {
-      callback({
-        event: "modified",
-        relativeUrl,
-      })
-    })
-    const removeRemovedCallback = projectFileRemoved.add((relativeUrl) => {
-      callback({
-        event: "removed",
-        relativeUrl,
-      })
-    })
-    const removeAddedCallback = projectFileRemoved.add((relativeUrl) => {
-      callback({
-        event: "added",
-        relativeUrl,
-      })
-    })
-    return () => {
-      removeModifiedCallback()
-      removeRemovedCallback()
-      removeAddedCallback()
-    }
-  }
-  // wait 100ms to actually start watching
-  // otherwise server starting is delayed by the filesystem scan done in
-  // registerDirectoryLifecycle
-  const timeout = setTimeout(() => {
-    const unregisterDirectoryLifecyle = registerDirectoryLifecycle(
-      rootDirectoryUrl,
-      {
-        watchDescription: {
-          ...autoreloadPatterns,
-          ".jsenv/": false,
-        },
-        updated: ({ relativeUrl }) => {
-          projectFileModified.notify(relativeUrl)
-        },
-        removed: ({ relativeUrl }) => {
-          projectFileRemoved.notify(relativeUrl)
-        },
-        added: ({ relativeUrl }) => {
-          projectFileAdded.notify(relativeUrl)
-        },
-        keepProcessAlive: false,
-        recursive: true,
-      },
-    )
-    destroyCallbackList.add(unregisterDirectoryLifecyle)
-  }, 100)
-  destroyCallbackList.add(() => {
-    clearTimeout(timeout)
-  })
-
-  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: () => {
-        const removeHotUpdateCallback = hotUpdateCallbackList.add(
-          (hotUpdate) => {
-            if (hotUpdate.declined) {
-              sseRoom.sendEvent({
-                type: "reload",
-                data: JSON.stringify({
-                  cause: hotUpdate.cause,
-                  type: "full",
-                  typeReason: hotUpdate.reason,
-                  declinedBy: hotUpdate.declinedBy,
-                }),
-              })
-            } else {
-              sseRoom.sendEvent({
-                type: "reload",
-                data: JSON.stringify({
-                  cause: hotUpdate.cause,
-                  type: "hot",
-                  typeReason: hotUpdate.reason,
-                  hotInstructions: hotUpdate.instructions,
-                }),
-              })
-            }
-          },
-        )
-        const stopWatching = watchProjectFiles(({ relativeUrl, event }) => {
-          onFileChange({ relativeUrl, event })
-        })
-        return () => {
-          removeHotUpdateCallback()
-          stopWatching()
-        }
-      },
-    })
-
-    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()
-    },
-  }
-}